diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
index cd7d692b0a..17a009a2ce 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
@@ -17,10 +17,12 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI;
 using osuTK;
 using osuTK.Graphics;
@@ -129,6 +131,31 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("no DHOs shown", () => !this.ChildrenOfType<DrawableTestHitObject>().Any());
         }
 
+        [Test]
+        public void TestApplyHitResultOnKilled()
+        {
+            ManualClock clock = null;
+            bool anyJudged = false;
+
+            void onNewResult(JudgementResult _) => anyJudged = true;
+
+            var beatmap = new Beatmap();
+            beatmap.HitObjects.Add(new TestKilledHitObject { Duration = 20 });
+
+            createTest(beatmap, 10, () => new FramedClock(clock = new ManualClock()));
+
+            AddStep("subscribe to new result", () =>
+            {
+                anyJudged = false;
+                drawableRuleset.NewResult += onNewResult;
+            });
+            AddStep("skip past object", () => clock.CurrentTime = beatmap.HitObjects[0].GetEndTime() + 1000);
+
+            AddAssert("object judged", () => anyJudged);
+
+            AddStep("clean up", () => drawableRuleset.NewResult -= onNewResult);
+        }
+
         private void createTest(IBeatmap beatmap, int poolSize, Func<IFrameBasedClock> createClock = null) => AddStep("create test", () =>
         {
             var ruleset = new TestPoolingRuleset();
@@ -192,6 +219,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             private void load()
             {
                 RegisterPool<TestHitObject, DrawableTestHitObject>(poolSize);
+                RegisterPool<TestKilledHitObject, DrawableTestKilledHitObject>(poolSize);
             }
 
             protected override HitObjectLifetimeEntry CreateLifetimeEntry(HitObject hitObject) => new TestHitObjectLifetimeEntry(hitObject);
@@ -220,19 +248,30 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
             {
-                yield return new TestHitObject
+                switch (original)
                 {
-                    StartTime = original.StartTime,
-                    Duration = 250
-                };
+                    case TestKilledHitObject h:
+                        yield return h;
+
+                        break;
+
+                    default:
+                        yield return new TestHitObject
+                        {
+                            StartTime = original.StartTime,
+                            Duration = 250
+                        };
+
+                        break;
+                }
             }
         }
 
         #endregion
 
-        #region HitObject
+        #region HitObjects
 
-        private class TestHitObject : ConvertHitObject
+        private class TestHitObject : ConvertHitObject, IHasDuration
         {
             public double EndTime => StartTime + Duration;
 
@@ -287,6 +326,30 @@ namespace osu.Game.Tests.Visual.Gameplay
             }
         }
 
+        private class TestKilledHitObject : TestHitObject
+        {
+        }
+
+        private class DrawableTestKilledHitObject : DrawableHitObject<TestKilledHitObject>
+        {
+            public DrawableTestKilledHitObject()
+                : base(null)
+            {
+            }
+
+            protected override void UpdateHitStateTransforms(ArmedState state)
+            {
+                base.UpdateHitStateTransforms(state);
+                Expire();
+            }
+
+            public override void OnKilled()
+            {
+                base.OnKilled();
+                ApplyResult(r => r.Type = r.Judgement.MinResult);
+            }
+        }
+
         #endregion
     }
 }
diff --git a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
index 689321698a..edc1696456 100644
--- a/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
+++ b/osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs
@@ -231,8 +231,8 @@ namespace osu.Game.Tests.Visual.Online
                 });
             });
 
-            AddAssert("shown beatmaps of current ruleset", () => overlay.Header.Picker.Difficulties.All(b => b.Beatmap.Ruleset.Equals(overlay.Header.RulesetSelector.Current.Value)));
-            AddAssert("left-most beatmap selected", () => overlay.Header.Picker.Difficulties.First().State == BeatmapPicker.DifficultySelectorState.Selected);
+            AddAssert("shown beatmaps of current ruleset", () => overlay.Header.HeaderContent.Picker.Difficulties.All(b => b.Beatmap.Ruleset.Equals(overlay.Header.RulesetSelector.Current.Value)));
+            AddAssert("left-most beatmap selected", () => overlay.Header.HeaderContent.Picker.Difficulties.First().State == BeatmapPicker.DifficultySelectorState.Selected);
         }
 
         [Test]
@@ -310,12 +310,12 @@ namespace osu.Game.Tests.Visual.Online
 
         private void downloadAssert(bool shown)
         {
-            AddAssert($"is download button {(shown ? "shown" : "hidden")}", () => overlay.Header.DownloadButtonsVisible == shown);
+            AddAssert($"is download button {(shown ? "shown" : "hidden")}", () => overlay.Header.HeaderContent.DownloadButtonsVisible == shown);
         }
 
         private class TestBeatmapSetOverlay : BeatmapSetOverlay
         {
-            public new Header Header => base.Header;
+            public new BeatmapSetHeader Header => base.Header;
         }
     }
 }
diff --git a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs
index a4c87d3ace..319c2bc6fd 100644
--- a/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs
+++ b/osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs
@@ -11,12 +11,10 @@ using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.OnlinePlay;
-using osu.Game.Screens.OnlinePlay.Match.Components;
 using osu.Game.Screens.OnlinePlay.Playlists;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Users;
@@ -85,8 +83,7 @@ namespace osu.Game.Tests.Visual.Playlists
 
             AddStep("move mouse to create button", () =>
             {
-                var footer = match.ChildrenOfType<Footer>().Single();
-                InputManager.MoveMouseTo(footer.ChildrenOfType<OsuButton>().Single());
+                InputManager.MoveMouseTo(this.ChildrenOfType<PlaylistsMatchSettingsOverlay.CreateRoomButton>().Single());
             });
 
             AddStep("click", () => InputManager.Click(MouseButton.Left));
diff --git a/osu.Game/OsuGameBase.cs b/osu.Game/OsuGameBase.cs
index 1f8ae54e55..20d88d33f2 100644
--- a/osu.Game/OsuGameBase.cs
+++ b/osu.Game/OsuGameBase.cs
@@ -327,6 +327,7 @@ namespace osu.Game
 
             if (!SelectedMods.Disabled)
                 SelectedMods.Value = Array.Empty<Mod>();
+
             AvailableMods.Value = dict;
         }
 
diff --git a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeader.cs b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeader.cs
index 6511b15fc8..4b26b02a8e 100644
--- a/osu.Game/Overlays/BeatmapSet/BeatmapSetHeader.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeader.cs
@@ -1,25 +1,55 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Effects;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Overlays.BeatmapSet
 {
     public class BeatmapSetHeader : OverlayHeader
     {
-        public readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
+        public readonly Bindable<BeatmapSetInfo> BeatmapSet = new Bindable<BeatmapSetInfo>();
 
+        public BeatmapSetHeaderContent HeaderContent { get; private set; }
+
+        [Cached]
         public BeatmapRulesetSelector RulesetSelector { get; private set; }
 
-        protected override OverlayTitle CreateTitle() => new BeatmapHeaderTitle();
+        [Cached(typeof(IBindable<RulesetInfo>))]
+        private readonly Bindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
+
+        public BeatmapSetHeader()
+        {
+            Masking = true;
+
+            EdgeEffect = new EdgeEffectParameters
+            {
+                Colour = Color4.Black.Opacity(0.25f),
+                Type = EdgeEffectType.Shadow,
+                Radius = 3,
+                Offset = new Vector2(0f, 1f),
+            };
+        }
+
+        protected override Drawable CreateContent() => HeaderContent = new BeatmapSetHeaderContent
+        {
+            BeatmapSet = { BindTarget = BeatmapSet }
+        };
 
         protected override Drawable CreateTitleContent() => RulesetSelector = new BeatmapRulesetSelector
         {
-            Current = Ruleset
+            Current = ruleset
         };
 
+        protected override OverlayTitle CreateTitle() => new BeatmapHeaderTitle();
+
         private class BeatmapHeaderTitle : OverlayTitle
         {
             public BeatmapHeaderTitle()
diff --git a/osu.Game/Overlays/BeatmapSet/Header.cs b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
similarity index 53%
rename from osu.Game/Overlays/BeatmapSet/Header.cs
rename to osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
index 916c21c010..153aa41582 100644
--- a/osu.Game/Overlays/BeatmapSet/Header.cs
+++ b/osu.Game/Overlays/BeatmapSet/BeatmapSetHeaderContent.cs
@@ -3,12 +3,10 @@
 
 using System.Linq;
 using osu.Framework.Allocation;
-using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
@@ -18,18 +16,21 @@ using osu.Game.Online;
 using osu.Game.Online.API;
 using osu.Game.Overlays.BeatmapListing.Panels;
 using osu.Game.Overlays.BeatmapSet.Buttons;
-using osu.Game.Rulesets;
 using osuTK;
-using osuTK.Graphics;
 
 namespace osu.Game.Overlays.BeatmapSet
 {
-    public class Header : BeatmapDownloadTrackingComposite
+    public class BeatmapSetHeaderContent : BeatmapDownloadTrackingComposite
     {
         private const float transition_duration = 200;
         private const float buttons_height = 45;
         private const float buttons_spacing = 5;
 
+        public bool DownloadButtonsVisible => downloadButtonsContainer.Any();
+
+        public readonly Details Details;
+        public readonly BeatmapPicker Picker;
+
         private readonly UpdateableBeatmapSetCover cover;
         private readonly Box coverGradient;
         private readonly OsuSpriteText title, artist;
@@ -38,185 +39,154 @@ namespace osu.Game.Overlays.BeatmapSet
         private readonly FillFlowContainer downloadButtonsContainer;
         private readonly BeatmapAvailability beatmapAvailability;
         private readonly BeatmapSetOnlineStatusPill onlineStatusPill;
-        public Details Details;
-
-        public bool DownloadButtonsVisible => downloadButtonsContainer.Any();
+        private readonly FavouriteButton favouriteButton;
+        private readonly FillFlowContainer fadeContent;
+        private readonly LoadingSpinner loading;
 
         [Resolved]
         private IAPIProvider api { get; set; }
 
-        public BeatmapRulesetSelector RulesetSelector => beatmapSetHeader.RulesetSelector;
-        public readonly BeatmapPicker Picker;
+        [Resolved]
+        private BeatmapRulesetSelector rulesetSelector { get; set; }
 
-        private readonly FavouriteButton favouriteButton;
-        private readonly FillFlowContainer fadeContent;
-        private readonly LoadingSpinner loading;
-        private readonly BeatmapSetHeader beatmapSetHeader;
-
-        [Cached(typeof(IBindable<RulesetInfo>))]
-        private readonly Bindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
-
-        public Header()
+        public BeatmapSetHeaderContent()
         {
             ExternalLinkButton externalLink;
 
             RelativeSizeAxes = Axes.X;
             AutoSizeAxes = Axes.Y;
-            Masking = true;
-
-            EdgeEffect = new EdgeEffectParameters
-            {
-                Colour = Color4.Black.Opacity(0.25f),
-                Type = EdgeEffectType.Shadow,
-                Radius = 3,
-                Offset = new Vector2(0f, 1f),
-            };
-
-            InternalChild = new FillFlowContainer
+            InternalChild = new Container
             {
                 RelativeSizeAxes = Axes.X,
                 AutoSizeAxes = Axes.Y,
-                Direction = FillDirection.Vertical,
                 Children = new Drawable[]
                 {
-                    beatmapSetHeader = new BeatmapSetHeader
+                    new Container
                     {
-                        Ruleset = { BindTarget = ruleset },
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            cover = new UpdateableBeatmapSetCover
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Masking = true,
+                            },
+                            coverGradient = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both
+                            },
+                        },
                     },
                     new Container
                     {
                         RelativeSizeAxes = Axes.X,
                         AutoSizeAxes = Axes.Y,
+                        Padding = new MarginPadding
+                        {
+                            Vertical = BeatmapSetOverlay.Y_PADDING,
+                            Left = BeatmapSetOverlay.X_PADDING,
+                            Right = BeatmapSetOverlay.X_PADDING + BeatmapSetOverlay.RIGHT_WIDTH,
+                        },
                         Children = new Drawable[]
                         {
-                            new Container
-                            {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
-                                {
-                                    cover = new UpdateableBeatmapSetCover
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Masking = true,
-                                    },
-                                    coverGradient = new Box
-                                    {
-                                        RelativeSizeAxes = Axes.Both
-                                    },
-                                },
-                            },
-                            new Container
+                            fadeContent = new FillFlowContainer
                             {
                                 RelativeSizeAxes = Axes.X,
                                 AutoSizeAxes = Axes.Y,
-                                Padding = new MarginPadding
-                                {
-                                    Vertical = BeatmapSetOverlay.Y_PADDING,
-                                    Left = BeatmapSetOverlay.X_PADDING,
-                                    Right = BeatmapSetOverlay.X_PADDING + BeatmapSetOverlay.RIGHT_WIDTH,
-                                },
+                                Direction = FillDirection.Vertical,
                                 Children = new Drawable[]
                                 {
-                                    fadeContent = new FillFlowContainer
+                                    new Container
                                     {
                                         RelativeSizeAxes = Axes.X,
                                         AutoSizeAxes = Axes.Y,
-                                        Direction = FillDirection.Vertical,
+                                        Child = Picker = new BeatmapPicker(),
+                                    },
+                                    new FillFlowContainer
+                                    {
+                                        Direction = FillDirection.Horizontal,
+                                        AutoSizeAxes = Axes.Both,
+                                        Margin = new MarginPadding { Top = 15 },
                                         Children = new Drawable[]
                                         {
-                                            new Container
+                                            title = new OsuSpriteText
                                             {
-                                                RelativeSizeAxes = Axes.X,
-                                                AutoSizeAxes = Axes.Y,
-                                                Child = Picker = new BeatmapPicker(),
+                                                Font = OsuFont.GetFont(size: 30, weight: FontWeight.SemiBold, italics: true)
                                             },
-                                            new FillFlowContainer
+                                            externalLink = new ExternalLinkButton
                                             {
-                                                Direction = FillDirection.Horizontal,
-                                                AutoSizeAxes = Axes.Both,
-                                                Margin = new MarginPadding { Top = 15 },
-                                                Children = new Drawable[]
-                                                {
-                                                    title = new OsuSpriteText
-                                                    {
-                                                        Font = OsuFont.GetFont(size: 30, weight: FontWeight.SemiBold, italics: true)
-                                                    },
-                                                    externalLink = new ExternalLinkButton
-                                                    {
-                                                        Anchor = Anchor.BottomLeft,
-                                                        Origin = Anchor.BottomLeft,
-                                                        Margin = new MarginPadding { Left = 5, Bottom = 4 }, // To better lineup with the font
-                                                    },
-                                                    explicitContentPill = new ExplicitContentBeatmapPill
-                                                    {
-                                                        Alpha = 0f,
-                                                        Anchor = Anchor.BottomLeft,
-                                                        Origin = Anchor.BottomLeft,
-                                                        Margin = new MarginPadding { Left = 10, Bottom = 4 },
-                                                    }
-                                                }
+                                                Anchor = Anchor.BottomLeft,
+                                                Origin = Anchor.BottomLeft,
+                                                Margin = new MarginPadding { Left = 5, Bottom = 4 }, // To better lineup with the font
                                             },
-                                            artist = new OsuSpriteText
+                                            explicitContentPill = new ExplicitContentBeatmapPill
                                             {
-                                                Font = OsuFont.GetFont(size: 20, weight: FontWeight.Medium, italics: true),
-                                                Margin = new MarginPadding { Bottom = 20 }
+                                                Alpha = 0f,
+                                                Anchor = Anchor.BottomLeft,
+                                                Origin = Anchor.BottomLeft,
+                                                Margin = new MarginPadding { Left = 10, Bottom = 4 },
+                                            }
+                                        }
+                                    },
+                                    artist = new OsuSpriteText
+                                    {
+                                        Font = OsuFont.GetFont(size: 20, weight: FontWeight.Medium, italics: true),
+                                        Margin = new MarginPadding { Bottom = 20 }
+                                    },
+                                    new Container
+                                    {
+                                        RelativeSizeAxes = Axes.X,
+                                        AutoSizeAxes = Axes.Y,
+                                        Child = author = new AuthorInfo(),
+                                    },
+                                    beatmapAvailability = new BeatmapAvailability(),
+                                    new Container
+                                    {
+                                        RelativeSizeAxes = Axes.X,
+                                        Height = buttons_height,
+                                        Margin = new MarginPadding { Top = 10 },
+                                        Children = new Drawable[]
+                                        {
+                                            favouriteButton = new FavouriteButton
+                                            {
+                                                BeatmapSet = { BindTarget = BeatmapSet }
                                             },
-                                            new Container
+                                            downloadButtonsContainer = new FillFlowContainer
                                             {
-                                                RelativeSizeAxes = Axes.X,
-                                                AutoSizeAxes = Axes.Y,
-                                                Child = author = new AuthorInfo(),
-                                            },
-                                            beatmapAvailability = new BeatmapAvailability(),
-                                            new Container
-                                            {
-                                                RelativeSizeAxes = Axes.X,
-                                                Height = buttons_height,
-                                                Margin = new MarginPadding { Top = 10 },
-                                                Children = new Drawable[]
-                                                {
-                                                    favouriteButton = new FavouriteButton
-                                                    {
-                                                        BeatmapSet = { BindTarget = BeatmapSet }
-                                                    },
-                                                    downloadButtonsContainer = new FillFlowContainer
-                                                    {
-                                                        RelativeSizeAxes = Axes.Both,
-                                                        Padding = new MarginPadding { Left = buttons_height + buttons_spacing },
-                                                        Spacing = new Vector2(buttons_spacing),
-                                                    },
-                                                },
+                                                RelativeSizeAxes = Axes.Both,
+                                                Padding = new MarginPadding { Left = buttons_height + buttons_spacing },
+                                                Spacing = new Vector2(buttons_spacing),
                                             },
                                         },
                                     },
-                                }
-                            },
-                            loading = new LoadingSpinner
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Scale = new Vector2(1.5f),
-                            },
-                            new FillFlowContainer
-                            {
-                                Anchor = Anchor.BottomRight,
-                                Origin = Anchor.BottomRight,
-                                AutoSizeAxes = Axes.Both,
-                                Margin = new MarginPadding { Top = BeatmapSetOverlay.Y_PADDING, Right = BeatmapSetOverlay.X_PADDING },
-                                Direction = FillDirection.Vertical,
-                                Spacing = new Vector2(10),
-                                Children = new Drawable[]
-                                {
-                                    onlineStatusPill = new BeatmapSetOnlineStatusPill
-                                    {
-                                        Anchor = Anchor.TopRight,
-                                        Origin = Anchor.TopRight,
-                                        TextSize = 14,
-                                        TextPadding = new MarginPadding { Horizontal = 35, Vertical = 10 }
-                                    },
-                                    Details = new Details(),
                                 },
                             },
+                        }
+                    },
+                    loading = new LoadingSpinner
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Scale = new Vector2(1.5f),
+                    },
+                    new FillFlowContainer
+                    {
+                        Anchor = Anchor.BottomRight,
+                        Origin = Anchor.BottomRight,
+                        AutoSizeAxes = Axes.Both,
+                        Margin = new MarginPadding { Top = BeatmapSetOverlay.Y_PADDING, Right = BeatmapSetOverlay.X_PADDING },
+                        Direction = FillDirection.Vertical,
+                        Spacing = new Vector2(10),
+                        Children = new Drawable[]
+                        {
+                            onlineStatusPill = new BeatmapSetOnlineStatusPill
+                            {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                                TextSize = 14,
+                                TextPadding = new MarginPadding { Horizontal = 35, Vertical = 10 }
+                            },
+                            Details = new Details(),
                         },
                     },
                 }
@@ -239,7 +209,7 @@ namespace osu.Game.Overlays.BeatmapSet
 
             BeatmapSet.BindValueChanged(setInfo =>
             {
-                Picker.BeatmapSet = RulesetSelector.BeatmapSet = author.BeatmapSet = beatmapAvailability.BeatmapSet = Details.BeatmapSet = setInfo.NewValue;
+                Picker.BeatmapSet = rulesetSelector.BeatmapSet = author.BeatmapSet = beatmapAvailability.BeatmapSet = Details.BeatmapSet = setInfo.NewValue;
                 cover.BeatmapSet = setInfo.NewValue;
 
                 if (setInfo.NewValue == null)
diff --git a/osu.Game/Overlays/BeatmapSetOverlay.cs b/osu.Game/Overlays/BeatmapSetOverlay.cs
index bbec62a85a..c16ec339bb 100644
--- a/osu.Game/Overlays/BeatmapSetOverlay.cs
+++ b/osu.Game/Overlays/BeatmapSetOverlay.cs
@@ -19,15 +19,12 @@ using osuTK;
 
 namespace osu.Game.Overlays
 {
-    public class BeatmapSetOverlay : FullscreenOverlay<OverlayHeader> // we don't provide a standard header for now.
+    public class BeatmapSetOverlay : FullscreenOverlay<BeatmapSetHeader>
     {
         public const float X_PADDING = 40;
         public const float Y_PADDING = 25;
         public const float RIGHT_WIDTH = 275;
 
-        //todo: should be an OverlayHeader? or maybe not?
-        protected new readonly Header Header;
-
         [Resolved]
         private RulesetStore rulesets { get; set; }
 
@@ -39,7 +36,7 @@ namespace osu.Game.Overlays
         private readonly Box background;
 
         public BeatmapSetOverlay()
-            : base(OverlayColourScheme.Blue, null)
+            : base(OverlayColourScheme.Blue, new BeatmapSetHeader())
         {
             OverlayScrollContainer scroll;
             Info info;
@@ -72,14 +69,14 @@ namespace osu.Game.Overlays
                                     Direction = FillDirection.Vertical,
                                     Children = new Drawable[]
                                     {
-                                        Header = new Header(),
+                                        Header,
                                         info = new Info()
                                     }
                                 },
                             },
                             new ScoresContainer
                             {
-                                Beatmap = { BindTarget = Header.Picker.Beatmap }
+                                Beatmap = { BindTarget = Header.HeaderContent.Picker.Beatmap }
                             },
                             comments = new CommentsSection()
                         },
@@ -91,7 +88,7 @@ namespace osu.Game.Overlays
             info.BeatmapSet.BindTo(beatmapSet);
             comments.BeatmapSet.BindTo(beatmapSet);
 
-            Header.Picker.Beatmap.ValueChanged += b =>
+            Header.HeaderContent.Picker.Beatmap.ValueChanged += b =>
             {
                 info.Beatmap = b.NewValue;
 
@@ -125,7 +122,7 @@ namespace osu.Game.Overlays
             req.Success += res =>
             {
                 beatmapSet.Value = res.ToBeatmapSet(rulesets);
-                Header.Picker.Beatmap.Value = Header.BeatmapSet.Value.Beatmaps.First(b => b.OnlineBeatmapID == beatmapId);
+                Header.HeaderContent.Picker.Beatmap.Value = Header.BeatmapSet.Value.Beatmaps.First(b => b.OnlineBeatmapID == beatmapId);
             };
             API.Queue(req);
 
diff --git a/osu.Game/Overlays/HoldToConfirmOverlay.cs b/osu.Game/Overlays/HoldToConfirmOverlay.cs
index eb325d8dd3..0542f66b5b 100644
--- a/osu.Game/Overlays/HoldToConfirmOverlay.cs
+++ b/osu.Game/Overlays/HoldToConfirmOverlay.cs
@@ -24,6 +24,13 @@ namespace osu.Game.Overlays
         [Resolved]
         private AudioManager audio { get; set; }
 
+        private readonly float finalFillAlpha;
+
+        protected HoldToConfirmOverlay(float finalFillAlpha = 1)
+        {
+            this.finalFillAlpha = finalFillAlpha;
+        }
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -42,8 +49,10 @@ namespace osu.Game.Overlays
 
             Progress.ValueChanged += p =>
             {
-                audioVolume.Value = 1 - p.NewValue;
-                overlay.Alpha = (float)p.NewValue;
+                var target = p.NewValue * finalFillAlpha;
+
+                audioVolume.Value = 1 - target;
+                overlay.Alpha = (float)target;
             };
 
             audio.Tracks.AddAdjustment(AdjustableProperty.Volume, audioVolume);
diff --git a/osu.Game/Overlays/Mods/ModSelectOverlay.cs b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
index 0c8245bebe..b93602116b 100644
--- a/osu.Game/Overlays/Mods/ModSelectOverlay.cs
+++ b/osu.Game/Overlays/Mods/ModSelectOverlay.cs
@@ -30,6 +30,7 @@ namespace osu.Game.Overlays.Mods
 {
     public class ModSelectOverlay : WaveOverlayContainer
     {
+        private readonly Func<Mod, bool> isValidMod;
         public const float HEIGHT = 510;
 
         protected readonly TriangleButton DeselectAllButton;
@@ -60,8 +61,10 @@ namespace osu.Game.Overlays.Mods
 
         private SampleChannel sampleOn, sampleOff;
 
-        public ModSelectOverlay()
+        public ModSelectOverlay(Func<Mod, bool> isValidMod = null)
         {
+            this.isValidMod = isValidMod ?? (m => true);
+
             Waves.FirstWaveColour = Color4Extensions.FromHex(@"19b0e2");
             Waves.SecondWaveColour = Color4Extensions.FromHex(@"2280a2");
             Waves.ThirdWaveColour = Color4Extensions.FromHex(@"005774");
@@ -403,7 +406,7 @@ namespace osu.Game.Overlays.Mods
             if (mods.NewValue == null) return;
 
             foreach (var section in ModSectionsContainer.Children)
-                section.Mods = mods.NewValue[section.ModType];
+                section.Mods = mods.NewValue[section.ModType].Where(isValidMod);
         }
 
         private void selectedModsChanged(ValueChangedEvent<IReadOnlyList<Mod>> mods)
diff --git a/osu.Game/Overlays/Settings/Sections/SkinSection.cs b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
index e29f97c33e..4cfd801caf 100644
--- a/osu.Game/Overlays/Settings/Sections/SkinSection.cs
+++ b/osu.Game/Overlays/Settings/Sections/SkinSection.cs
@@ -38,6 +38,18 @@ namespace osu.Game.Overlays.Settings.Sections
 
         private List<SkinInfo> skinItems;
 
+        private int firstNonDefaultSkinIndex
+        {
+            get
+            {
+                var index = skinItems.FindIndex(s => s.ID > 0);
+                if (index < 0)
+                    index = skinItems.Count;
+
+                return index;
+            }
+        }
+
         [Resolved]
         private SkinManager skins { get; set; }
 
@@ -112,21 +124,22 @@ namespace osu.Game.Overlays.Settings.Sections
         private void updateItems()
         {
             skinItems = skins.GetAllUsableSkins();
-
-            // insert after lazer built-in skins
-            int firstNonDefault = skinItems.FindIndex(s => s.ID > 0);
-            if (firstNonDefault < 0)
-                firstNonDefault = skinItems.Count;
-
-            skinItems.Insert(firstNonDefault, random_skin_info);
-
+            skinItems.Insert(firstNonDefaultSkinIndex, random_skin_info);
+            sortUserSkins(skinItems);
             skinDropdown.Items = skinItems;
         }
 
         private void itemUpdated(ValueChangedEvent<WeakReference<SkinInfo>> weakItem)
         {
             if (weakItem.NewValue.TryGetTarget(out var item))
-                Schedule(() => skinDropdown.Items = skinDropdown.Items.Where(i => !i.Equals(item)).Append(item).ToArray());
+            {
+                Schedule(() =>
+                {
+                    List<SkinInfo> newDropdownItems = skinDropdown.Items.Where(i => !i.Equals(item)).Append(item).ToList();
+                    sortUserSkins(newDropdownItems);
+                    skinDropdown.Items = newDropdownItems;
+                });
+            }
         }
 
         private void itemRemoved(ValueChangedEvent<WeakReference<SkinInfo>> weakItem)
@@ -135,6 +148,13 @@ namespace osu.Game.Overlays.Settings.Sections
                 Schedule(() => skinDropdown.Items = skinDropdown.Items.Where(i => i.ID != item.ID).ToArray());
         }
 
+        private void sortUserSkins(List<SkinInfo> skinsList)
+        {
+            // Sort user skins separately from built-in skins
+            skinsList.Sort(firstNonDefaultSkinIndex, skinsList.Count - firstNonDefaultSkinIndex,
+                Comparer<SkinInfo>.Create((a, b) => string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase)));
+        }
+
         private class SkinSettingsDropdown : SettingsDropdown<SkinInfo>
         {
             protected override OsuDropdown<SkinInfo> CreateDropdown() => new SkinDropdownControl();
diff --git a/osu.Game/Rulesets/UI/HitObjectContainer.cs b/osu.Game/Rulesets/UI/HitObjectContainer.cs
index 12e39d4fbf..1972043ccb 100644
--- a/osu.Game/Rulesets/UI/HitObjectContainer.cs
+++ b/osu.Game/Rulesets/UI/HitObjectContainer.cs
@@ -124,9 +124,11 @@ namespace osu.Game.Rulesets.UI
             Debug.Assert(drawableMap.ContainsKey(entry));
 
             var drawable = drawableMap[entry];
+
+            // OnKilled can potentially change the hitobject's result, so it needs to run first before unbinding.
+            drawable.OnKilled();
             drawable.OnNewResult -= onNewResult;
             drawable.OnRevertResult -= onRevertResult;
-            drawable.OnKilled();
 
             drawableMap.Remove(entry);
 
diff --git a/osu.Game/Screens/Menu/ExitConfirmOverlay.cs b/osu.Game/Screens/Menu/ExitConfirmOverlay.cs
index db2faeb60a..a491283e5f 100644
--- a/osu.Game/Screens/Menu/ExitConfirmOverlay.cs
+++ b/osu.Game/Screens/Menu/ExitConfirmOverlay.cs
@@ -13,6 +13,11 @@ namespace osu.Game.Screens.Menu
 
         public void Abort() => AbortConfirm();
 
+        public ExitConfirmOverlay()
+            : base(0.7f)
+        {
+        }
+
         public bool OnPressed(GlobalAction action)
         {
             if (action == GlobalAction.Back)
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSongSelect.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSongSelect.cs
index 36dbb9e792..ebc06d2445 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSongSelect.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSongSelect.cs
@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Online.Rooms;
+using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Select;
@@ -109,5 +110,9 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         }
 
         protected override BeatmapDetailArea CreateBeatmapDetailArea() => new PlayBeatmapDetailArea();
+
+        protected override ModSelectOverlay CreateModSelectOverlay() => new ModSelectOverlay(isValidMod);
+
+        private bool isValidMod(Mod mod) => !(mod is ModAutoplay) && (mod as MultiMod)?.Mods.Any(mm => mm is ModAutoplay) != true;
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
index 80991569dc..7c4b6d18ec 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/MultiplayerMatchSubScreen.cs
@@ -44,6 +44,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         [CanBeNull]
         private IDisposable readyClickOperation;
 
+        private GridContainer mainContent;
+
         public MultiplayerMatchSubScreen(Room room)
         {
             Title = room.RoomID.Value == null ? "New room" : room.Name.Value;
@@ -55,7 +57,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
         {
             InternalChildren = new Drawable[]
             {
-                new GridContainer
+                mainContent = new GridContainer
                 {
                     RelativeSizeAxes = Axes.Both,
                     Content = new[]
@@ -178,6 +180,19 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer
                     State = { Value = client.Room == null ? Visibility.Visible : Visibility.Hidden }
                 }
             };
+
+            if (client.Room == null)
+            {
+                // A new room is being created.
+                // The main content should be hidden until the settings overlay is hidden, signaling the room is ready to be displayed.
+                mainContent.Hide();
+
+                settingsOverlay.State.BindValueChanged(visibility =>
+                {
+                    if (visibility.NewValue == Visibility.Hidden)
+                        mainContent.Show();
+                }, true);
+            }
         }
 
         protected override void LoadComplete()
diff --git a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
index e76ca995bf..22580f0537 100644
--- a/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSubScreen.cs
@@ -33,6 +33,8 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
         private OverlinedHeader participantsHeader;
 
+        private GridContainer mainContent;
+
         public PlaylistsRoomSubScreen(Room room)
         {
             Title = room.RoomID.Value == null ? "New playlist" : room.Name.Value;
@@ -44,7 +46,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         {
             InternalChildren = new Drawable[]
             {
-                new GridContainer
+                mainContent = new GridContainer
                 {
                     RelativeSizeAxes = Axes.Both,
                     Content = new[]
@@ -190,6 +192,19 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                     State = { Value = roomId.Value == null ? Visibility.Visible : Visibility.Hidden }
                 }
             };
+
+            if (roomId.Value == null)
+            {
+                // A new room is being created.
+                // The main content should be hidden until the settings overlay is hidden, signaling the room is ready to be displayed.
+                mainContent.Hide();
+
+                settingsOverlay.State.BindValueChanged(visibility =>
+                {
+                    if (visibility.NewValue == Visibility.Hidden)
+                        mainContent.Show();
+                }, true);
+            }
         }
 
         [Resolved]
diff --git a/osu.Game/Screens/Select/MatchSongSelect.cs b/osu.Game/Screens/Select/MatchSongSelect.cs
index 0948a4d19a..ed47b5d5ac 100644
--- a/osu.Game/Screens/Select/MatchSongSelect.cs
+++ b/osu.Game/Screens/Select/MatchSongSelect.cs
@@ -10,6 +10,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Online.Rooms;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.OnlinePlay;
 using osu.Game.Screens.OnlinePlay.Components;
 
@@ -78,5 +80,9 @@ namespace osu.Game.Screens.Select
             item.RequiredMods.Clear();
             item.RequiredMods.AddRange(Mods.Value.Select(m => m.CreateCopy()));
         }
+
+        protected override ModSelectOverlay CreateModSelectOverlay() => new ModSelectOverlay(isValidMod);
+
+        private bool isValidMod(Mod mod) => !(mod is ModAutoplay) && (mod as MultiMod)?.Mods.Any(mm => mm is ModAutoplay) != true;
     }
 }
diff --git a/osu.Game/Screens/Select/SongSelect.cs b/osu.Game/Screens/Select/SongSelect.cs
index 6c0bd3a228..4fca77a176 100644
--- a/osu.Game/Screens/Select/SongSelect.cs
+++ b/osu.Game/Screens/Select/SongSelect.cs
@@ -251,11 +251,7 @@ namespace osu.Game.Screens.Select
                                     Children = new Drawable[]
                                     {
                                         BeatmapOptions = new BeatmapOptionsOverlay(),
-                                        ModSelect = new ModSelectOverlay
-                                        {
-                                            Origin = Anchor.BottomCentre,
-                                            Anchor = Anchor.BottomCentre,
-                                        }
+                                        ModSelect = CreateModSelectOverlay()
                                     }
                                 }
                             }
@@ -305,6 +301,8 @@ namespace osu.Game.Screens.Select
             }
         }
 
+        protected virtual ModSelectOverlay CreateModSelectOverlay() => new ModSelectOverlay();
+
         protected virtual void ApplyFilterToCarousel(FilterCriteria criteria)
         {
             // if not the current screen, we want to get carousel in a good presentation state before displaying (resume or enter).
diff --git a/osu.Game/Tests/Beatmaps/LegacyBeatmapSkinColourTest.cs b/osu.Game/Tests/Beatmaps/LegacyBeatmapSkinColourTest.cs
index fb3432fbae..051ede30b7 100644
--- a/osu.Game/Tests/Beatmaps/LegacyBeatmapSkinColourTest.cs
+++ b/osu.Game/Tests/Beatmaps/LegacyBeatmapSkinColourTest.cs
@@ -17,7 +17,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Tests.Beatmaps
 {
-    public class LegacyBeatmapSkinColourTest : ScreenTestScene
+    public abstract class LegacyBeatmapSkinColourTest : ScreenTestScene
     {
         protected readonly Bindable<bool> BeatmapSkins = new Bindable<bool>();
         protected readonly Bindable<bool> BeatmapColours = new Bindable<bool>();