diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchStartControl.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchStartControl.cs
new file mode 100644
index 0000000000..a374488306
--- /dev/null
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMatchStartControl.cs
@@ -0,0 +1,338 @@
+// 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 System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.Countdown;
+using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
+using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
+using osu.Game.Tests.Resources;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestSceneMatchStartControl : MultiplayerTestScene
+    {
+        private MatchStartControl control;
+        private BeatmapSetInfo importedSet;
+
+        private readonly Bindable<PlaylistItem> selectedItem = new Bindable<PlaylistItem>();
+
+        private BeatmapManager beatmaps;
+        private RulesetStore rulesets;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host, AudioManager audio)
+        {
+            Dependencies.Cache(rulesets = new RealmRulesetStore(Realm));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, Realm, rulesets, null, audio, Resources, host, Beatmap.Default));
+            Dependencies.Cache(Realm);
+        }
+
+        [SetUp]
+        public new void Setup() => Schedule(() =>
+        {
+            AvailabilityTracker.SelectedItem.BindTo(selectedItem);
+
+            beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
+            importedSet = beatmaps.GetAllUsableBeatmapSets().First();
+            Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
+
+            selectedItem.Value = new PlaylistItem(Beatmap.Value.BeatmapInfo)
+            {
+                RulesetID = Beatmap.Value.BeatmapInfo.Ruleset.OnlineID
+            };
+
+            Child = new PopoverContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = control = new MatchStartControl
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(200, 50),
+                }
+            };
+        });
+
+        [Test]
+        public void TestStartWithCountdown()
+        {
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("countdown button shown", () => this.ChildrenOfType<MultiplayerCountdownButton>().SingleOrDefault()?.IsPresent == true);
+            ClickButtonWhenEnabled<MultiplayerCountdownButton>();
+            AddStep("click the first countdown button", () =>
+            {
+                var popoverButton = this.ChildrenOfType<Popover>().Single().ChildrenOfType<OsuButton>().First();
+                InputManager.MoveMouseTo(popoverButton);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("countdown button not visible", () => !this.ChildrenOfType<MultiplayerCountdownButton>().Single().IsPresent);
+            AddStep("finish countdown", () => MultiplayerClient.SkipToEndOfCountdown());
+            AddUntilStep("match started", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.WaitingForLoad);
+        }
+
+        [Test]
+        public void TestCancelCountdown()
+        {
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("countdown button shown", () => this.ChildrenOfType<MultiplayerCountdownButton>().SingleOrDefault()?.IsPresent == true);
+            ClickButtonWhenEnabled<MultiplayerCountdownButton>();
+            AddStep("click the first countdown button", () =>
+            {
+                var popoverButton = this.ChildrenOfType<Popover>().Single().ChildrenOfType<OsuButton>().First();
+                InputManager.MoveMouseTo(popoverButton);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+
+            AddStep("finish countdown", () => MultiplayerClient.SkipToEndOfCountdown());
+            AddUntilStep("match not started", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.Ready);
+        }
+
+        [Test]
+        public void TestReadyAndUnReadyDuringCountdown()
+        {
+            AddStep("add second user as host", () =>
+            {
+                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
+                MultiplayerClient.TransferHost(2);
+            });
+
+            AddStep("start with countdown", () => MultiplayerClient.SendMatchRequest(new StartMatchCountdownRequest { Duration = TimeSpan.FromMinutes(2) }).WaitSafely());
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is idle", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
+        }
+
+        [Test]
+        public void TestCountdownButtonEnablementAndVisibilityWhileSpectating()
+        {
+            AddStep("set spectating", () => MultiplayerClient.ChangeUserState(API.LocalUser.Value.OnlineID, MultiplayerUserState.Spectating));
+            AddUntilStep("local user is spectating", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.Spectating);
+
+            AddAssert("countdown button is visible", () => this.ChildrenOfType<MultiplayerCountdownButton>().Single().IsPresent);
+            AddAssert("countdown button disabled", () => !this.ChildrenOfType<MultiplayerCountdownButton>().Single().Enabled.Value);
+
+            AddStep("add second user", () => MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" }));
+            AddAssert("countdown button disabled", () => !this.ChildrenOfType<MultiplayerCountdownButton>().Single().Enabled.Value);
+
+            AddStep("set second user ready", () => MultiplayerClient.ChangeUserState(2, MultiplayerUserState.Ready));
+            AddAssert("countdown button enabled", () => this.ChildrenOfType<MultiplayerCountdownButton>().Single().Enabled.Value);
+        }
+
+        [Test]
+        public void TestSpectatingDuringCountdownWithNoReadyUsersCancelsCountdown()
+        {
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("countdown button shown", () => this.ChildrenOfType<MultiplayerCountdownButton>().SingleOrDefault()?.IsPresent == true);
+            ClickButtonWhenEnabled<MultiplayerCountdownButton>();
+            AddStep("click the first countdown button", () =>
+            {
+                var popoverButton = this.ChildrenOfType<Popover>().Single().ChildrenOfType<OsuButton>().First();
+                InputManager.MoveMouseTo(popoverButton);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("set spectating", () => MultiplayerClient.ChangeUserState(API.LocalUser.Value.OnlineID, MultiplayerUserState.Spectating));
+            AddUntilStep("local user is spectating", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.Spectating);
+
+            AddStep("finish countdown", () => MultiplayerClient.SkipToEndOfCountdown());
+            AddUntilStep("match not started", () => MultiplayerClient.Room?.State == MultiplayerRoomState.Open);
+        }
+
+        [Test]
+        public void TestReadyButtonEnabledWhileSpectatingDuringCountdown()
+        {
+            AddStep("add second user", () => MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" }));
+            AddStep("set second user ready", () => MultiplayerClient.ChangeUserState(2, MultiplayerUserState.Ready));
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("countdown button shown", () => this.ChildrenOfType<MultiplayerCountdownButton>().SingleOrDefault()?.IsPresent == true);
+            ClickButtonWhenEnabled<MultiplayerCountdownButton>();
+            AddStep("click the first countdown button", () =>
+            {
+                var popoverButton = this.ChildrenOfType<Popover>().Single().ChildrenOfType<OsuButton>().First();
+                InputManager.MoveMouseTo(popoverButton);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddStep("set spectating", () => MultiplayerClient.ChangeUserState(API.LocalUser.Value.OnlineID, MultiplayerUserState.Spectating));
+            AddUntilStep("local user is spectating", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.Spectating);
+
+            AddAssert("ready button enabled", () => this.ChildrenOfType<MultiplayerReadyButton>().Single().Enabled.Value);
+        }
+
+        [Test]
+        public void TestBecomeHostDuringCountdownAndReady()
+        {
+            AddStep("add second user as host", () =>
+            {
+                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
+                MultiplayerClient.TransferHost(2);
+            });
+
+            AddStep("start countdown", () => MultiplayerClient.SendMatchRequest(new StartMatchCountdownRequest { Duration = TimeSpan.FromMinutes(1) }).WaitSafely());
+            AddUntilStep("countdown started", () => MultiplayerClient.Room?.Countdown != null);
+
+            AddStep("transfer host to local user", () => MultiplayerClient.TransferHost(API.LocalUser.Value.OnlineID));
+            AddUntilStep("local user is host", () => MultiplayerClient.Room?.Host?.Equals(MultiplayerClient.LocalUser) == true);
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("local user became ready", () => MultiplayerClient.LocalUser?.State == MultiplayerUserState.Ready);
+            AddAssert("countdown still active", () => MultiplayerClient.Room?.Countdown != null);
+        }
+
+        [Test]
+        public void TestDeletedBeatmapDisableReady()
+        {
+            OsuButton readyButton = null;
+
+            AddUntilStep("ensure ready button enabled", () =>
+            {
+                readyButton = control.ChildrenOfType<OsuButton>().Single();
+                return readyButton.Enabled.Value;
+            });
+
+            AddStep("delete beatmap", () => beatmaps.Delete(importedSet));
+            AddUntilStep("ready button disabled", () => !readyButton.Enabled.Value);
+            AddStep("undelete beatmap", () => beatmaps.Undelete(importedSet));
+            AddUntilStep("ready button enabled back", () => readyButton.Enabled.Value);
+        }
+
+        [Test]
+        public void TestToggleStateWhenNotHost()
+        {
+            AddStep("add second user as host", () =>
+            {
+                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
+                MultiplayerClient.TransferHost(2);
+            });
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is idle", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestToggleStateWhenHost(bool allReady)
+        {
+            AddStep("setup", () =>
+            {
+                MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
+
+                if (!allReady)
+                    MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
+            });
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
+
+            verifyGameplayStartFlow();
+        }
+
+        [Test]
+        public void TestBecomeHostWhileReady()
+        {
+            AddStep("add host", () =>
+            {
+                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
+                MultiplayerClient.TransferHost(2);
+            });
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddStep("make user host", () => MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0));
+
+            verifyGameplayStartFlow();
+        }
+
+        [Test]
+        public void TestLoseHostWhileReady()
+        {
+            AddStep("setup", () =>
+            {
+                MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
+                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
+            });
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
+
+            AddStep("transfer host", () => MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[1].UserID ?? 0));
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user is idle (match not started)", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
+            AddUntilStep("ready button enabled", () => control.ChildrenOfType<OsuButton>().Single().Enabled.Value);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestManyUsersChangingState(bool isHost)
+        {
+            const int users = 10;
+            AddStep("setup", () =>
+            {
+                MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
+                for (int i = 0; i < users; i++)
+                    MultiplayerClient.AddUser(new APIUser { Id = i, Username = "Another user" });
+            });
+
+            if (!isHost)
+                AddStep("transfer host", () => MultiplayerClient.TransferHost(2));
+
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+
+            AddRepeatStep("change user ready state", () =>
+            {
+                MultiplayerClient.ChangeUserState(RNG.Next(0, users), RNG.NextBool() ? MultiplayerUserState.Ready : MultiplayerUserState.Idle);
+            }, 20);
+
+            AddRepeatStep("ready all users", () =>
+            {
+                var nextUnready = MultiplayerClient.Room?.Users.FirstOrDefault(c => c.State == MultiplayerUserState.Idle);
+                if (nextUnready != null)
+                    MultiplayerClient.ChangeUserState(nextUnready.UserID, MultiplayerUserState.Ready);
+            }, users);
+        }
+
+        private void verifyGameplayStartFlow()
+        {
+            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
+            ClickButtonWhenEnabled<MultiplayerReadyButton>();
+            AddUntilStep("user waiting for load", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.WaitingForLoad);
+
+            AddStep("finish gameplay", () =>
+            {
+                MultiplayerClient.ChangeUserState(MultiplayerClient.Room?.Users[0].UserID ?? 0, MultiplayerUserState.Loaded);
+                MultiplayerClient.ChangeUserState(MultiplayerClient.Room?.Users[0].UserID ?? 0, MultiplayerUserState.FinishedPlay);
+            });
+
+            AddUntilStep("ready button enabled", () => control.ChildrenOfType<OsuButton>().Single().Enabled.Value);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index e38da96bd5..d0765fc4b3 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -41,6 +41,7 @@ using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Spectate;
 using osu.Game.Tests.Resources;
 using osuTK.Input;
+using ReadyButton = osu.Game.Screens.OnlinePlay.Components.ReadyButton;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -424,7 +425,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("Beatmap doesn't match current item", () => Beatmap.Value.BeatmapInfo.OnlineID != multiplayerClient.Room?.Playlist.First().BeatmapID);
 
-            AddStep("start match externally", () => multiplayerClient.StartMatch());
+            AddStep("start match externally", () => multiplayerClient.StartMatch().WaitSafely());
 
             AddUntilStep("play started", () => multiplayerComponents.CurrentScreen is Player);
 
@@ -462,7 +463,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("Ruleset doesn't match current item", () => Ruleset.Value.OnlineID != multiplayerClient.Room?.Playlist.First().RulesetID);
 
-            AddStep("start match externally", () => multiplayerClient.StartMatch());
+            AddStep("start match externally", () => multiplayerClient.StartMatch().WaitSafely());
 
             AddUntilStep("play started", () => multiplayerComponents.CurrentScreen is Player);
 
@@ -500,7 +501,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddAssert("Mods don't match current item", () => !SelectedMods.Value.Select(m => m.Acronym).SequenceEqual(multiplayerClient.Room.AsNonNull().Playlist.First().RequiredMods.Select(m => m.Acronym)));
 
-            AddStep("start match externally", () => multiplayerClient.StartMatch());
+            AddStep("start match externally", () => multiplayerClient.StartMatch().WaitSafely());
 
             AddUntilStep("play started", () => multiplayerComponents.CurrentScreen is Player);
 
@@ -535,7 +536,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for spectating user state", () => multiplayerClient.LocalUser?.State == MultiplayerUserState.Spectating);
 
-            AddStep("start match externally", () => multiplayerClient.StartMatch());
+            AddStep("start match externally", () => multiplayerClient.StartMatch().WaitSafely());
 
             AddAssert("play not started", () => multiplayerComponents.IsCurrentScreen());
         }
@@ -568,7 +569,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddUntilStep("wait for spectating user state", () => multiplayerClient.LocalUser?.State == MultiplayerUserState.Spectating);
 
-            AddStep("start match externally", () => multiplayerClient.StartMatch());
+            AddStep("start match externally", () => multiplayerClient.StartMatch().WaitSafely());
 
             AddStep("restore beatmap", () =>
             {
@@ -883,7 +884,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 AddStep("start match by other user", () =>
                 {
                     multiplayerClient.ChangeUserState(1234, MultiplayerUserState.Ready);
-                    multiplayerClient.StartMatch();
+                    multiplayerClient.StartMatch().WaitSafely();
                 });
 
                 AddUntilStep("wait for loading", () => multiplayerClient.Room?.State == MultiplayerRoomState.WaitingForLoad);
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerReadyButton.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerReadyButton.cs
deleted file mode 100644
index dd13d2b6ef..0000000000
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerReadyButton.cs
+++ /dev/null
@@ -1,199 +0,0 @@
-// 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 System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Bindables;
-using osu.Framework.Extensions;
-using osu.Framework.Graphics;
-using osu.Framework.Platform;
-using osu.Framework.Testing;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Online.Rooms;
-using osu.Game.Rulesets;
-using osu.Game.Screens.OnlinePlay.Multiplayer.Match;
-using osu.Game.Tests.Resources;
-using osuTK;
-
-namespace osu.Game.Tests.Visual.Multiplayer
-{
-    public class TestSceneMultiplayerReadyButton : MultiplayerTestScene
-    {
-        private MultiplayerReadyButton button;
-        private BeatmapSetInfo importedSet;
-
-        private readonly Bindable<PlaylistItem> selectedItem = new Bindable<PlaylistItem>();
-
-        private BeatmapManager beatmaps;
-        private RulesetStore rulesets;
-
-        [BackgroundDependencyLoader]
-        private void load(GameHost host, AudioManager audio)
-        {
-            Dependencies.Cache(rulesets = new RealmRulesetStore(Realm));
-            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, Realm, rulesets, null, audio, Resources, host, Beatmap.Default));
-            Dependencies.Cache(Realm);
-        }
-
-        [SetUp]
-        public new void Setup() => Schedule(() =>
-        {
-            AvailabilityTracker.SelectedItem.BindTo(selectedItem);
-
-            beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).WaitSafely();
-            importedSet = beatmaps.GetAllUsableBeatmapSets().First();
-            Beatmap.Value = beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First());
-
-            selectedItem.Value = new PlaylistItem(Beatmap.Value.BeatmapInfo)
-            {
-                RulesetID = Beatmap.Value.BeatmapInfo.Ruleset.OnlineID
-            };
-
-            if (button != null)
-                Remove(button);
-
-            Add(button = new MultiplayerReadyButton
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Size = new Vector2(200, 50),
-            });
-        });
-
-        [Test]
-        public void TestDeletedBeatmapDisableReady()
-        {
-            OsuButton readyButton = null;
-
-            AddUntilStep("ensure ready button enabled", () =>
-            {
-                readyButton = button.ChildrenOfType<OsuButton>().Single();
-                return readyButton.Enabled.Value;
-            });
-
-            AddStep("delete beatmap", () => beatmaps.Delete(importedSet));
-            AddUntilStep("ready button disabled", () => !readyButton.Enabled.Value);
-            AddStep("undelete beatmap", () => beatmaps.Undelete(importedSet));
-            AddUntilStep("ready button enabled back", () => readyButton.Enabled.Value);
-        }
-
-        [Test]
-        public void TestToggleStateWhenNotHost()
-        {
-            AddStep("add second user as host", () =>
-            {
-                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
-                MultiplayerClient.TransferHost(2);
-            });
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddUntilStep("user is idle", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
-        }
-
-        [TestCase(true)]
-        [TestCase(false)]
-        public void TestToggleStateWhenHost(bool allReady)
-        {
-            AddStep("setup", () =>
-            {
-                MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
-
-                if (!allReady)
-                    MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
-            });
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
-
-            verifyGameplayStartFlow();
-        }
-
-        [Test]
-        public void TestBecomeHostWhileReady()
-        {
-            AddStep("add host", () =>
-            {
-                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
-                MultiplayerClient.TransferHost(2);
-            });
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddStep("make user host", () => MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0));
-
-            verifyGameplayStartFlow();
-        }
-
-        [Test]
-        public void TestLoseHostWhileReady()
-        {
-            AddStep("setup", () =>
-            {
-                MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
-                MultiplayerClient.AddUser(new APIUser { Id = 2, Username = "Another user" });
-            });
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
-
-            AddStep("transfer host", () => MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[1].UserID ?? 0));
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddUntilStep("user is idle (match not started)", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Idle);
-            AddUntilStep("ready button enabled", () => button.ChildrenOfType<OsuButton>().Single().Enabled.Value);
-        }
-
-        [TestCase(true)]
-        [TestCase(false)]
-        public void TestManyUsersChangingState(bool isHost)
-        {
-            const int users = 10;
-            AddStep("setup", () =>
-            {
-                MultiplayerClient.TransferHost(MultiplayerClient.Room?.Users[0].UserID ?? 0);
-                for (int i = 0; i < users; i++)
-                    MultiplayerClient.AddUser(new APIUser { Id = i, Username = "Another user" });
-            });
-
-            if (!isHost)
-                AddStep("transfer host", () => MultiplayerClient.TransferHost(2));
-
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-
-            AddRepeatStep("change user ready state", () =>
-            {
-                MultiplayerClient.ChangeUserState(RNG.Next(0, users), RNG.NextBool() ? MultiplayerUserState.Ready : MultiplayerUserState.Idle);
-            }, 20);
-
-            AddRepeatStep("ready all users", () =>
-            {
-                var nextUnready = MultiplayerClient.Room?.Users.FirstOrDefault(c => c.State == MultiplayerUserState.Idle);
-                if (nextUnready != null)
-                    MultiplayerClient.ChangeUserState(nextUnready.UserID, MultiplayerUserState.Ready);
-            }, users);
-        }
-
-        private void verifyGameplayStartFlow()
-        {
-            AddUntilStep("user is ready", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.Ready);
-            ClickButtonWhenEnabled<MultiplayerReadyButton>();
-            AddUntilStep("user waiting for load", () => MultiplayerClient.Room?.Users[0].State == MultiplayerUserState.WaitingForLoad);
-
-            AddStep("finish gameplay", () =>
-            {
-                MultiplayerClient.ChangeUserState(MultiplayerClient.Room?.Users[0].UserID ?? 0, MultiplayerUserState.Loaded);
-                MultiplayerClient.ChangeUserState(MultiplayerClient.Room?.Users[0].UserID ?? 0, MultiplayerUserState.FinishedPlay);
-            });
-
-            AddUntilStep("ready button enabled", () => button.ChildrenOfType<OsuButton>().Single().Enabled.Value);
-        }
-    }
-}
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs
index 33ad0fd1de..13917f4eb0 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerSpectateButton.cs
@@ -9,6 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -26,7 +27,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
     public class TestSceneMultiplayerSpectateButton : MultiplayerTestScene
     {
         private MultiplayerSpectateButton spectateButton;
-        private MultiplayerReadyButton readyButton;
+        private MatchStartControl startControl;
 
         private readonly Bindable<PlaylistItem> selectedItem = new Bindable<PlaylistItem>();
 
@@ -56,23 +57,27 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 RulesetID = Beatmap.Value.BeatmapInfo.Ruleset.OnlineID,
             };
 
-            Child = new FillFlowContainer
+            Child = new PopoverContainer
             {
-                AutoSizeAxes = Axes.Both,
-                Direction = FillDirection.Vertical,
-                Children = new Drawable[]
+                RelativeSizeAxes = Axes.Both,
+                Child = new FillFlowContainer
                 {
-                    spectateButton = new MultiplayerSpectateButton
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
                     {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Size = new Vector2(200, 50),
-                    },
-                    readyButton = new MultiplayerReadyButton
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Size = new Vector2(200, 50),
+                        spectateButton = new MultiplayerSpectateButton
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(200, 50),
+                        },
+                        startControl = new MatchStartControl
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(200, 50),
+                        }
                     }
                 }
             };
@@ -141,6 +146,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
             => AddUntilStep($"spectate button {(shouldBeEnabled ? "is" : "is not")} enabled", () => spectateButton.ChildrenOfType<OsuButton>().Single().Enabled.Value == shouldBeEnabled);
 
         private void assertReadyButtonEnablement(bool shouldBeEnabled)
-            => AddUntilStep($"ready button {(shouldBeEnabled ? "is" : "is not")} enabled", () => readyButton.ChildrenOfType<OsuButton>().Single().Enabled.Value == shouldBeEnabled);
+            => AddUntilStep($"ready button {(shouldBeEnabled ? "is" : "is not")} enabled", () => startControl.ChildrenOfType<MultiplayerReadyButton>().Single().Enabled.Value == shouldBeEnabled);
     }
 }
diff --git a/osu.Game/Online/Multiplayer/Countdown/CountdownChangedEvent.cs b/osu.Game/Online/Multiplayer/Countdown/CountdownChangedEvent.cs
new file mode 100644
index 0000000000..b067f3b235
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/Countdown/CountdownChangedEvent.cs
@@ -0,0 +1,22 @@
+// 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.
+
+#nullable enable
+
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.Countdown
+{
+    /// <summary>
+    /// Indicates a change to the <see cref="MultiplayerRoom"/>'s countdown.
+    /// </summary>
+    [MessagePackObject]
+    public class CountdownChangedEvent : MatchServerEvent
+    {
+        /// <summary>
+        /// The new countdown.
+        /// </summary>
+        [Key(0)]
+        public MultiplayerCountdown? Countdown { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/Countdown/StartMatchCountdownRequest.cs b/osu.Game/Online/Multiplayer/Countdown/StartMatchCountdownRequest.cs
new file mode 100644
index 0000000000..08eab26090
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/Countdown/StartMatchCountdownRequest.cs
@@ -0,0 +1,23 @@
+// 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 System;
+using MessagePack;
+
+#nullable enable
+
+namespace osu.Game.Online.Multiplayer.Countdown
+{
+    /// <summary>
+    /// A request for a countdown to start the match.
+    /// </summary>
+    [MessagePackObject]
+    public class StartMatchCountdownRequest : MatchUserRequest
+    {
+        /// <summary>
+        /// How long the countdown should last.
+        /// </summary>
+        [Key(0)]
+        public TimeSpan Duration { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/Countdown/StopCountdownRequest.cs b/osu.Game/Online/Multiplayer/Countdown/StopCountdownRequest.cs
new file mode 100644
index 0000000000..20a0e32734
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/Countdown/StopCountdownRequest.cs
@@ -0,0 +1,17 @@
+// 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.
+
+#nullable enable
+
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer.Countdown
+{
+    /// <summary>
+    /// Request to stop the current countdown.
+    /// </summary>
+    [MessagePackObject]
+    public class StopCountdownRequest : MatchUserRequest
+    {
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchServerEvent.cs b/osu.Game/Online/Multiplayer/MatchServerEvent.cs
index 891fb2cc3b..4ce55e424d 100644
--- a/osu.Game/Online/Multiplayer/MatchServerEvent.cs
+++ b/osu.Game/Online/Multiplayer/MatchServerEvent.cs
@@ -1,8 +1,11 @@
 // 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.
 
+#nullable enable
+
 using System;
 using MessagePack;
+using osu.Game.Online.Multiplayer.Countdown;
 
 namespace osu.Game.Online.Multiplayer
 {
@@ -11,6 +14,8 @@ namespace osu.Game.Online.Multiplayer
     /// </summary>
     [Serializable]
     [MessagePackObject]
+    // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    [Union(0, typeof(CountdownChangedEvent))]
     public abstract class MatchServerEvent
     {
     }
diff --git a/osu.Game/Online/Multiplayer/MatchStartCountdown.cs b/osu.Game/Online/Multiplayer/MatchStartCountdown.cs
new file mode 100644
index 0000000000..6c1cdd97d3
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MatchStartCountdown.cs
@@ -0,0 +1,17 @@
+// 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.
+
+#nullable enable
+
+using MessagePack;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// A <see cref="MultiplayerCountdown"/> which will start the match after ending.
+    /// </summary>
+    [MessagePackObject]
+    public class MatchStartCountdown : MultiplayerCountdown
+    {
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MatchTypes/TeamVersus/ChangeTeamRequest.cs b/osu.Game/Online/Multiplayer/MatchTypes/TeamVersus/ChangeTeamRequest.cs
index 9c3b07049c..a26a2b3fc2 100644
--- a/osu.Game/Online/Multiplayer/MatchTypes/TeamVersus/ChangeTeamRequest.cs
+++ b/osu.Game/Online/Multiplayer/MatchTypes/TeamVersus/ChangeTeamRequest.cs
@@ -7,6 +7,7 @@ using MessagePack;
 
 namespace osu.Game.Online.Multiplayer.MatchTypes.TeamVersus
 {
+    [MessagePackObject]
     public class ChangeTeamRequest : MatchUserRequest
     {
         [Key(0)]
diff --git a/osu.Game/Online/Multiplayer/MatchUserRequest.cs b/osu.Game/Online/Multiplayer/MatchUserRequest.cs
index 8c6809e7f3..888b55e428 100644
--- a/osu.Game/Online/Multiplayer/MatchUserRequest.cs
+++ b/osu.Game/Online/Multiplayer/MatchUserRequest.cs
@@ -3,6 +3,7 @@
 
 using System;
 using MessagePack;
+using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 
 namespace osu.Game.Online.Multiplayer
@@ -12,7 +13,10 @@ namespace osu.Game.Online.Multiplayer
     /// </summary>
     [Serializable]
     [MessagePackObject]
-    [Union(0, typeof(ChangeTeamRequest))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    [Union(0, typeof(ChangeTeamRequest))]
+    [Union(1, typeof(StartMatchCountdownRequest))]
+    [Union(2, typeof(StopCountdownRequest))]
     public abstract class MatchUserRequest
     {
     }
diff --git a/osu.Game/Online/Multiplayer/MultiplayerClient.cs b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
index a56cc7f8d6..2d5496c5c1 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerClient.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerClient.cs
@@ -16,6 +16,7 @@ using osu.Framework.Logging;
 using osu.Game.Database;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Rooms;
 using osu.Game.Online.Rooms.RoomStatuses;
 using osu.Game.Rulesets;
@@ -534,7 +535,24 @@ namespace osu.Game.Online.Multiplayer
 
         public Task MatchEvent(MatchServerEvent e)
         {
-            // not used by any match types just yet.
+            if (Room == null)
+                return Task.CompletedTask;
+
+            Scheduler.Add(() =>
+            {
+                if (Room == null)
+                    return;
+
+                switch (e)
+                {
+                    case CountdownChangedEvent countdownChangedEvent:
+                        Room.Countdown = countdownChangedEvent.Countdown;
+                        break;
+                }
+
+                RoomUpdated?.Invoke();
+            }, false);
+
             return Task.CompletedTask;
         }
 
diff --git a/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs b/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
new file mode 100644
index 0000000000..81190e64c9
--- /dev/null
+++ b/osu.Game/Online/Multiplayer/MultiplayerCountdown.cs
@@ -0,0 +1,28 @@
+// 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.
+
+#nullable enable
+
+using System;
+using MessagePack;
+using osu.Game.Online.Multiplayer.Countdown;
+
+namespace osu.Game.Online.Multiplayer
+{
+    /// <summary>
+    /// Describes the current countdown in a <see cref="MultiplayerRoom"/>.
+    /// </summary>
+    [MessagePackObject]
+    [Union(0, typeof(MatchStartCountdown))] // IMPORTANT: Add rules to SignalRUnionWorkaroundResolver for new derived types.
+    public abstract class MultiplayerCountdown
+    {
+        /// <summary>
+        /// The amount of time remaining in the countdown.
+        /// </summary>
+        /// <remarks>
+        /// This is only sent once from the server upon initial retrieval of the <see cref="MultiplayerRoom"/> or via a <see cref="CountdownChangedEvent"/>.
+        /// </remarks>
+        [Key(0)]
+        public TimeSpan TimeRemaining { get; set; }
+    }
+}
diff --git a/osu.Game/Online/Multiplayer/MultiplayerRoom.cs b/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
index a60e70dab3..e215498ff9 100644
--- a/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
+++ b/osu.Game/Online/Multiplayer/MultiplayerRoom.cs
@@ -54,6 +54,12 @@ namespace osu.Game.Online.Multiplayer
         [Key(6)]
         public IList<MultiplayerPlaylistItem> Playlist { get; set; } = new List<MultiplayerPlaylistItem>();
 
+        /// <summary>
+        /// The currently-running countdown.
+        /// </summary>
+        [Key(7)]
+        public MultiplayerCountdown? Countdown { get; set; }
+
         [JsonConstructor]
         [SerializationConstructor]
         public MultiplayerRoom(long roomId)
diff --git a/osu.Game/Online/SignalRWorkaroundTypes.cs b/osu.Game/Online/SignalRWorkaroundTypes.cs
index f69d23d81c..156f916cef 100644
--- a/osu.Game/Online/SignalRWorkaroundTypes.cs
+++ b/osu.Game/Online/SignalRWorkaroundTypes.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 
 namespace osu.Game.Online
@@ -18,8 +19,12 @@ namespace osu.Game.Online
         internal static readonly IReadOnlyList<(Type derivedType, Type baseType)> BASE_TYPE_MAPPING = new[]
         {
             (typeof(ChangeTeamRequest), typeof(MatchUserRequest)),
+            (typeof(StartMatchCountdownRequest), typeof(MatchUserRequest)),
+            (typeof(StopCountdownRequest), typeof(MatchUserRequest)),
+            (typeof(CountdownChangedEvent), typeof(MatchServerEvent)),
             (typeof(TeamVersusRoomState), typeof(MatchRoomState)),
             (typeof(TeamVersusUserState), typeof(MatchUserState)),
+            (typeof(MatchStartCountdown), typeof(MultiplayerCountdown))
         };
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs b/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs
index 9822ceaaf6..cdaa39d2be 100644
--- a/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs
+++ b/osu.Game/Screens/OnlinePlay/Components/ReadyButton.cs
@@ -15,12 +15,12 @@ namespace osu.Game.Screens.OnlinePlay.Components
     {
         public new readonly BindableBool Enabled = new BindableBool();
 
-        private IBindable<BeatmapAvailability> availability;
+        private readonly IBindable<BeatmapAvailability> availability = new Bindable<BeatmapAvailability>();
 
         [BackgroundDependencyLoader]
         private void load(OnlinePlayBeatmapAvailabilityTracker beatmapTracker)
         {
-            availability = beatmapTracker.Availability.GetBoundCopy();
+            availability.BindTo(beatmapTracker.Availability);
 
             availability.BindValueChanged(_ => updateState());
             Enabled.BindValueChanged(_ => updateState(), true);
diff --git a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
index e297c90491..a382f65d84 100644
--- a/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs
@@ -12,6 +12,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Screens;
 using osu.Game.Audio;
@@ -100,122 +101,126 @@ namespace osu.Game.Screens.OnlinePlay.Match
         {
             sampleStart = audio.Samples.Get(@"SongSelect/confirm-selection");
 
-            InternalChildren = new Drawable[]
+            InternalChild = new PopoverContainer
             {
-                beatmapAvailabilityTracker,
-                new MultiplayerRoomSounds(),
-                new GridContainer
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    RowDimensions = new[]
+                    beatmapAvailabilityTracker,
+                    new MultiplayerRoomSounds(),
+                    new GridContainer
                     {
-                        new Dimension(),
-                        new Dimension(GridSizeMode.Absolute, 50)
-                    },
-                    Content = new[]
-                    {
-                        // Padded main content (drawable room + main content)
-                        new Drawable[]
+                        RelativeSizeAxes = Axes.Both,
+                        RowDimensions = new[]
                         {
-                            new Container
+                            new Dimension(),
+                            new Dimension(GridSizeMode.Absolute, 50)
+                        },
+                        Content = new[]
+                        {
+                            // Padded main content (drawable room + main content)
+                            new Drawable[]
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding
+                                new Container
                                 {
-                                    Horizontal = WaveOverlayContainer.WIDTH_PADDING,
-                                    Bottom = 30
-                                },
-                                Children = new[]
-                                {
-                                    mainContent = new GridContainer
+                                    RelativeSizeAxes = Axes.Both,
+                                    Padding = new MarginPadding
                                     {
-                                        RelativeSizeAxes = Axes.Both,
-                                        RowDimensions = new[]
+                                        Horizontal = WaveOverlayContainer.WIDTH_PADDING,
+                                        Bottom = 30
+                                    },
+                                    Children = new[]
+                                    {
+                                        mainContent = new GridContainer
                                         {
-                                            new Dimension(GridSizeMode.AutoSize),
-                                            new Dimension(GridSizeMode.Absolute, 10)
-                                        },
-                                        Content = new[]
-                                        {
-                                            new Drawable[]
+                                            RelativeSizeAxes = Axes.Both,
+                                            RowDimensions = new[]
                                             {
-                                                new DrawableMatchRoom(Room, allowEdit)
-                                                {
-                                                    OnEdit = () => settingsOverlay.Show(),
-                                                    SelectedItem = { BindTarget = SelectedItem }
-                                                }
+                                                new Dimension(GridSizeMode.AutoSize),
+                                                new Dimension(GridSizeMode.Absolute, 10)
                                             },
-                                            null,
-                                            new Drawable[]
+                                            Content = new[]
                                             {
-                                                new Container
+                                                new Drawable[]
                                                 {
-                                                    RelativeSizeAxes = Axes.Both,
-                                                    Children = new[]
+                                                    new DrawableMatchRoom(Room, allowEdit)
                                                     {
-                                                        new Container
+                                                        OnEdit = () => settingsOverlay.Show(),
+                                                        SelectedItem = { BindTarget = SelectedItem }
+                                                    }
+                                                },
+                                                null,
+                                                new Drawable[]
+                                                {
+                                                    new Container
+                                                    {
+                                                        RelativeSizeAxes = Axes.Both,
+                                                        Children = new[]
                                                         {
-                                                            RelativeSizeAxes = Axes.Both,
-                                                            Masking = true,
-                                                            CornerRadius = 10,
-                                                            Child = new Box
+                                                            new Container
                                                             {
                                                                 RelativeSizeAxes = Axes.Both,
-                                                                Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
+                                                                Masking = true,
+                                                                CornerRadius = 10,
+                                                                Child = new Box
+                                                                {
+                                                                    RelativeSizeAxes = Axes.Both,
+                                                                    Colour = Color4Extensions.FromHex(@"3e3a44") // Temporary.
+                                                                },
                                                             },
-                                                        },
-                                                        new Container
-                                                        {
-                                                            RelativeSizeAxes = Axes.Both,
-                                                            Padding = new MarginPadding(20),
-                                                            Child = CreateMainContent(),
-                                                        },
-                                                        new Container
-                                                        {
-                                                            Anchor = Anchor.BottomLeft,
-                                                            Origin = Anchor.BottomLeft,
-                                                            RelativeSizeAxes = Axes.X,
-                                                            AutoSizeAxes = Axes.Y,
-                                                            Child = userModsSelectOverlay = new UserModSelectOverlay
+                                                            new Container
                                                             {
-                                                                SelectedMods = { BindTarget = UserMods },
-                                                                IsValidMod = _ => false
-                                                            }
-                                                        },
+                                                                RelativeSizeAxes = Axes.Both,
+                                                                Padding = new MarginPadding(20),
+                                                                Child = CreateMainContent(),
+                                                            },
+                                                            new Container
+                                                            {
+                                                                Anchor = Anchor.BottomLeft,
+                                                                Origin = Anchor.BottomLeft,
+                                                                RelativeSizeAxes = Axes.X,
+                                                                AutoSizeAxes = Axes.Y,
+                                                                Child = userModsSelectOverlay = new UserModSelectOverlay
+                                                                {
+                                                                    SelectedMods = { BindTarget = UserMods },
+                                                                    IsValidMod = _ => false
+                                                                }
+                                                            },
+                                                        }
                                                     }
                                                 }
                                             }
+                                        },
+                                        new Container
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            // Resolves 1px masking errors between the settings overlay and the room panel.
+                                            Padding = new MarginPadding(-1),
+                                            Child = settingsOverlay = CreateRoomSettingsOverlay(Room)
                                         }
                                     },
-                                    new Container
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        // Resolves 1px masking errors between the settings overlay and the room panel.
-                                        Padding = new MarginPadding(-1),
-                                        Child = settingsOverlay = CreateRoomSettingsOverlay(Room)
-                                    }
                                 },
                             },
-                        },
-                        // Footer
-                        new Drawable[]
-                        {
-                            new Container
+                            // Footer
+                            new Drawable[]
                             {
-                                RelativeSizeAxes = Axes.Both,
-                                Children = new Drawable[]
+                                new Container
                                 {
-                                    new Box
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
                                     {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
-                                    },
-                                    new Container
-                                    {
-                                        RelativeSizeAxes = Axes.Both,
-                                        Padding = new MarginPadding(5),
-                                        Child = CreateFooter()
-                                    },
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = Color4Extensions.FromHex(@"28242d") // Temporary.
+                                        },
+                                        new Container
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Padding = new MarginPadding(5),
+                                            Child = CreateFooter()
+                                        },
+                                    }
                                 }
                             }
                         }
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MatchStartControl.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MatchStartControl.cs
new file mode 100644
index 0000000000..af7ed9b9e2
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MatchStartControl.cs
@@ -0,0 +1,224 @@
+// 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 System;
+using System.Diagnostics;
+using System.Linq;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Threading;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.Countdown;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
+{
+    public class MatchStartControl : MultiplayerRoomComposite
+    {
+        [Resolved]
+        private OngoingOperationTracker ongoingOperationTracker { get; set; }
+
+        [CanBeNull]
+        private IDisposable clickOperation;
+
+        private Sample sampleReady;
+        private Sample sampleReadyAll;
+        private Sample sampleUnready;
+
+        private readonly BindableBool enabled = new BindableBool();
+        private readonly MultiplayerCountdownButton countdownButton;
+        private int countReady;
+        private ScheduledDelegate readySampleDelegate;
+        private IBindable<bool> operationInProgress;
+
+        public MatchStartControl()
+        {
+            InternalChild = new GridContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                ColumnDimensions = new[]
+                {
+                    new Dimension(),
+                    new Dimension(GridSizeMode.AutoSize)
+                },
+                Content = new[]
+                {
+                    new Drawable[]
+                    {
+                        new MultiplayerReadyButton
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Size = Vector2.One,
+                            Action = onReadyClick,
+                            Enabled = { BindTarget = enabled },
+                        },
+                        countdownButton = new MultiplayerCountdownButton
+                        {
+                            RelativeSizeAxes = Axes.Y,
+                            Size = new Vector2(40, 1),
+                            Alpha = 0,
+                            Action = startCountdown,
+                            Enabled = { BindTarget = enabled }
+                        }
+                    }
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            operationInProgress = ongoingOperationTracker.InProgress.GetBoundCopy();
+            operationInProgress.BindValueChanged(_ => updateState());
+
+            sampleReady = audio.Samples.Get(@"Multiplayer/player-ready");
+            sampleReadyAll = audio.Samples.Get(@"Multiplayer/player-ready-all");
+            sampleUnready = audio.Samples.Get(@"Multiplayer/player-unready");
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            CurrentPlaylistItem.BindValueChanged(_ => updateState());
+        }
+
+        protected override void OnRoomUpdated()
+        {
+            base.OnRoomUpdated();
+            updateState();
+        }
+
+        protected override void OnRoomLoadRequested()
+        {
+            base.OnRoomLoadRequested();
+            endOperation();
+        }
+
+        private void onReadyClick()
+        {
+            if (Room == null)
+                return;
+
+            Debug.Assert(clickOperation == null);
+            clickOperation = ongoingOperationTracker.BeginOperation();
+
+            // Ensure the current user becomes ready before being able to do anything else (start match, stop countdown, unready).
+            if (!isReady() || !Client.IsHost)
+            {
+                toggleReady();
+                return;
+            }
+
+            // Local user is the room host and is in a ready state.
+            // The only action they can take is to stop a countdown if one's currently running.
+            if (Room.Countdown != null)
+            {
+                stopCountdown();
+                return;
+            }
+
+            // And if a countdown isn't running, start the match.
+            startMatch();
+
+            bool isReady() => Client.LocalUser?.State == MultiplayerUserState.Ready || Client.LocalUser?.State == MultiplayerUserState.Spectating;
+
+            void toggleReady() => Client.ToggleReady().ContinueWith(_ => endOperation());
+
+            void stopCountdown() => Client.SendMatchRequest(new StopCountdownRequest()).ContinueWith(_ => endOperation());
+
+            void startMatch() => Client.StartMatch().ContinueWith(t =>
+            {
+                // accessing Exception here silences any potential errors from the antecedent task
+                if (t.Exception != null)
+                {
+                    // gameplay was not started due to an exception; unblock button.
+                    endOperation();
+                }
+
+                // gameplay is starting, the button will be unblocked on load requested.
+            });
+        }
+
+        private void startCountdown(TimeSpan duration)
+        {
+            Debug.Assert(clickOperation == null);
+            clickOperation = ongoingOperationTracker.BeginOperation();
+
+            Client.SendMatchRequest(new StartMatchCountdownRequest { Duration = duration }).ContinueWith(_ => endOperation());
+        }
+
+        private void endOperation()
+        {
+            clickOperation?.Dispose();
+            clickOperation = null;
+        }
+
+        private void updateState()
+        {
+            if (Room == null)
+            {
+                enabled.Value = false;
+                return;
+            }
+
+            var localUser = Client.LocalUser;
+
+            int newCountReady = Room.Users.Count(u => u.State == MultiplayerUserState.Ready);
+            int newCountTotal = Room.Users.Count(u => u.State != MultiplayerUserState.Spectating);
+
+            if (Room.Countdown != null)
+                countdownButton.Alpha = 0;
+            else
+            {
+                switch (localUser?.State)
+                {
+                    default:
+                        countdownButton.Alpha = 0;
+                        break;
+
+                    case MultiplayerUserState.Spectating:
+                    case MultiplayerUserState.Ready:
+                        countdownButton.Alpha = Room.Host?.Equals(localUser) == true ? 1 : 0;
+                        break;
+                }
+            }
+
+            enabled.Value =
+                Room.State == MultiplayerRoomState.Open
+                && CurrentPlaylistItem.Value?.ID == Room.Settings.PlaylistItemId
+                && !Room.Playlist.Single(i => i.ID == Room.Settings.PlaylistItemId).Expired
+                && !operationInProgress.Value;
+
+            // When the local user is the host and spectating the match, the "start match" state should be enabled if any users are ready.
+            if (localUser?.State == MultiplayerUserState.Spectating)
+                enabled.Value &= Room.Host?.Equals(localUser) == true && newCountReady > 0;
+
+            if (newCountReady == countReady)
+                return;
+
+            readySampleDelegate?.Cancel();
+            readySampleDelegate = Schedule(() =>
+            {
+                if (newCountReady > countReady)
+                {
+                    if (newCountReady == newCountTotal)
+                        sampleReadyAll?.Play();
+                    else
+                        sampleReady?.Play();
+                }
+                else if (newCountReady < countReady)
+                {
+                    sampleUnready?.Play();
+                }
+
+                countReady = newCountReady;
+            });
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerCountdownButton.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerCountdownButton.cs
new file mode 100644
index 0000000000..3bf7e91a55
--- /dev/null
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerCountdownButton.cs
@@ -0,0 +1,83 @@
+// 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 System;
+using Humanizer;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Cursor;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
+using osuTK;
+
+namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
+{
+    public class MultiplayerCountdownButton : IconButton, IHasPopover
+    {
+        private static readonly TimeSpan[] available_delays =
+        {
+            TimeSpan.FromSeconds(10),
+            TimeSpan.FromSeconds(30),
+            TimeSpan.FromMinutes(1),
+            TimeSpan.FromMinutes(2)
+        };
+
+        public new Action<TimeSpan> Action;
+
+        private readonly Drawable background;
+
+        public MultiplayerCountdownButton()
+        {
+            Icon = FontAwesome.Solid.CaretDown;
+            IconScale = new Vector2(0.6f);
+
+            Add(background = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Depth = float.MaxValue
+            });
+
+            base.Action = this.ShowPopover;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.Green;
+        }
+
+        public Popover GetPopover()
+        {
+            var flow = new FillFlowContainer
+            {
+                Width = 200,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Spacing = new Vector2(2),
+            };
+
+            foreach (var duration in available_delays)
+            {
+                flow.Add(new OsuButton
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Text = $"Start match in {duration.Humanize()}",
+                    BackgroundColour = background.Colour,
+                    Action = () =>
+                    {
+                        Action(duration);
+                        this.HidePopover();
+                    }
+                });
+            }
+
+            return new OsuPopover { Child = flow };
+        }
+    }
+}
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchFooter.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchFooter.cs
index b4fce5903b..a07c95bca8 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchFooter.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerMatchFooter.cs
@@ -28,7 +28,7 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
                             RelativeSizeAxes = Axes.Both,
                         },
                         null,
-                        new MultiplayerReadyButton
+                        new MatchStartControl
                         {
                             RelativeSizeAxes = Axes.Both,
                         },
diff --git a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerReadyButton.cs b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerReadyButton.cs
index 0c80f6ef5b..746e4257f1 100644
--- a/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerReadyButton.cs
+++ b/osu.Game/Screens/OnlinePlay/Multiplayer/Match/MultiplayerReadyButton.cs
@@ -2,210 +2,177 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Sample;
-using osu.Framework.Bindables;
-using osu.Framework.Graphics;
+using osu.Framework.Localisation;
 using osu.Framework.Threading;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Backgrounds;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Screens.OnlinePlay.Components;
-using osuTK;
 
 namespace osu.Game.Screens.OnlinePlay.Multiplayer.Match
 {
-    public class MultiplayerReadyButton : MultiplayerRoomComposite
+    public class MultiplayerReadyButton : ReadyButton
     {
+        public new Triangles Triangles => base.Triangles;
+
+        [Resolved]
+        private MultiplayerClient multiplayerClient { get; set; }
+
         [Resolved]
         private OsuColour colours { get; set; }
 
-        [Resolved]
-        private OngoingOperationTracker ongoingOperationTracker { get; set; }
-
         [CanBeNull]
-        private IDisposable clickOperation;
-
-        private Sample sampleReady;
-        private Sample sampleReadyAll;
-        private Sample sampleUnready;
-
-        private readonly ButtonWithTrianglesExposed button;
-        private int countReady;
-        private ScheduledDelegate readySampleDelegate;
-        private IBindable<bool> operationInProgress;
-
-        public MultiplayerReadyButton()
-        {
-            InternalChild = button = new ButtonWithTrianglesExposed
-            {
-                RelativeSizeAxes = Axes.Both,
-                Size = Vector2.One,
-                Action = onReadyClick,
-                Enabled = { Value = true },
-            };
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
-        {
-            operationInProgress = ongoingOperationTracker.InProgress.GetBoundCopy();
-            operationInProgress.BindValueChanged(_ => updateState());
-
-            sampleReady = audio.Samples.Get(@"Multiplayer/player-ready");
-            sampleReadyAll = audio.Samples.Get(@"Multiplayer/player-ready-all");
-            sampleUnready = audio.Samples.Get(@"Multiplayer/player-unready");
-        }
+        private MultiplayerRoom room => multiplayerClient.Room;
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            CurrentPlaylistItem.BindValueChanged(_ => updateState());
+            multiplayerClient.RoomUpdated += onRoomUpdated;
+            onRoomUpdated();
         }
 
-        protected override void OnRoomUpdated()
+        private MultiplayerCountdown countdown;
+        private DateTimeOffset countdownReceivedTime;
+        private ScheduledDelegate countdownUpdateDelegate;
+
+        private void onRoomUpdated() => Scheduler.AddOnce(() =>
         {
-            base.OnRoomUpdated();
-            updateState();
-        }
+            if (countdown == null && room?.Countdown != null)
+                countdownReceivedTime = DateTimeOffset.Now;
 
-        protected override void OnRoomLoadRequested()
-        {
-            base.OnRoomLoadRequested();
-            endOperation();
-        }
+            countdown = room?.Countdown;
 
-        private void onReadyClick()
-        {
-            if (Room == null)
-                return;
-
-            Debug.Assert(clickOperation == null);
-            clickOperation = ongoingOperationTracker.BeginOperation();
-
-            // Ensure the current user becomes ready before being able to do anything else (start match, stop countdown, unready).
-            if (!isReady() || !Client.IsHost)
+            if (room?.Countdown != null)
+                countdownUpdateDelegate ??= Scheduler.AddDelayed(updateButtonText, 1000, true);
+            else
             {
-                toggleReady();
+                countdownUpdateDelegate?.Cancel();
+                countdownUpdateDelegate = null;
+            }
+
+            updateButtonText();
+            updateButtonColour();
+        });
+
+        private void updateButtonText()
+        {
+            if (room == null)
+            {
+                Text = "Ready";
                 return;
             }
 
-            // And if a countdown isn't running, start the match.
-            startMatch();
+            var localUser = multiplayerClient.LocalUser;
 
-            bool isReady() => Client.LocalUser?.State == MultiplayerUserState.Ready || Client.LocalUser?.State == MultiplayerUserState.Spectating;
+            int countReady = room.Users.Count(u => u.State == MultiplayerUserState.Ready);
+            int countTotal = room.Users.Count(u => u.State != MultiplayerUserState.Spectating);
+            string countText = $"({countReady} / {countTotal} ready)";
 
-            void toggleReady() => Client.ToggleReady().ContinueWith(_ => endOperation());
-
-            void startMatch() => Client.StartMatch().ContinueWith(t =>
+            if (countdown != null)
             {
-                // accessing Exception here silences any potential errors from the antecedent task
-                if (t.Exception != null)
+                TimeSpan timeElapsed = DateTimeOffset.Now - countdownReceivedTime;
+                TimeSpan countdownRemaining;
+
+                if (timeElapsed > countdown.TimeRemaining)
+                    countdownRemaining = TimeSpan.Zero;
+                else
+                    countdownRemaining = countdown.TimeRemaining - timeElapsed;
+
+                string countdownText = $"Starting in {countdownRemaining:mm\\:ss}";
+
+                switch (localUser?.State)
                 {
-                    // gameplay was not started due to an exception; unblock button.
-                    endOperation();
+                    default:
+                        Text = $"Ready ({countdownText.ToLowerInvariant()})";
+                        break;
+
+                    case MultiplayerUserState.Spectating:
+                    case MultiplayerUserState.Ready:
+                        Text = $"{countdownText} {countText}";
+                        break;
                 }
+            }
+            else
+            {
+                switch (localUser?.State)
+                {
+                    default:
+                        Text = "Ready";
+                        break;
 
-                // gameplay is starting, the button will be unblocked on load requested.
-            });
+                    case MultiplayerUserState.Spectating:
+                    case MultiplayerUserState.Ready:
+                        Text = room.Host?.Equals(localUser) == true
+                            ? $"Start match {countText}"
+                            : $"Waiting for host... {countText}";
+
+                        break;
+                }
+            }
         }
 
-        private void endOperation()
+        private void updateButtonColour()
         {
-            clickOperation?.Dispose();
-            clickOperation = null;
-        }
+            if (room == null)
+            {
+                setGreen();
+                return;
+            }
 
-        private void updateState()
-        {
-            var localUser = Client.LocalUser;
-
-            int newCountReady = Room?.Users.Count(u => u.State == MultiplayerUserState.Ready) ?? 0;
-            int newCountTotal = Room?.Users.Count(u => u.State != MultiplayerUserState.Spectating) ?? 0;
+            var localUser = multiplayerClient.LocalUser;
 
             switch (localUser?.State)
             {
                 default:
-                    button.Text = "Ready";
-                    updateButtonColour(true);
+                    setGreen();
                     break;
 
                 case MultiplayerUserState.Spectating:
                 case MultiplayerUserState.Ready:
-                    string countText = $"({newCountReady} / {newCountTotal} ready)";
-
-                    if (Room?.Host?.Equals(localUser) == true)
-                    {
-                        button.Text = $"Start match {countText}";
-                        updateButtonColour(true);
-                    }
+                    if (room?.Host?.Equals(localUser) == true && room.Countdown == null)
+                        setGreen();
                     else
-                    {
-                        button.Text = $"Waiting for host... {countText}";
-                        updateButtonColour(false);
-                    }
+                        setYellow();
 
                     break;
             }
 
-            bool enableButton =
-                Room?.State == MultiplayerRoomState.Open
-                && CurrentPlaylistItem.Value?.ID == Room.Settings.PlaylistItemId
-                && !Room.Playlist.Single(i => i.ID == Room.Settings.PlaylistItemId).Expired
-                && !operationInProgress.Value;
-
-            // When the local user is the host and spectating the match, the "start match" state should be enabled if any users are ready.
-            if (localUser?.State == MultiplayerUserState.Spectating)
-                enableButton &= Room?.Host?.Equals(localUser) == true && newCountReady > 0;
-
-            button.Enabled.Value = enableButton;
-
-            if (newCountReady == countReady)
-                return;
-
-            readySampleDelegate?.Cancel();
-            readySampleDelegate = Schedule(() =>
+            void setYellow()
             {
-                if (newCountReady > countReady)
-                {
-                    if (newCountReady == newCountTotal)
-                        sampleReadyAll?.Play();
-                    else
-                        sampleReady?.Play();
-                }
-                else if (newCountReady < countReady)
-                {
-                    sampleUnready?.Play();
-                }
-
-                countReady = newCountReady;
-            });
-        }
-
-        private void updateButtonColour(bool green)
-        {
-            if (green)
-            {
-                button.BackgroundColour = colours.Green;
-                button.Triangles.ColourDark = colours.Green;
-                button.Triangles.ColourLight = colours.GreenLight;
+                BackgroundColour = colours.YellowDark;
+                Triangles.ColourDark = colours.YellowDark;
+                Triangles.ColourLight = colours.Yellow;
             }
-            else
+
+            void setGreen()
             {
-                button.BackgroundColour = colours.YellowDark;
-                button.Triangles.ColourDark = colours.YellowDark;
-                button.Triangles.ColourLight = colours.Yellow;
+                BackgroundColour = colours.Green;
+                Triangles.ColourDark = colours.Green;
+                Triangles.ColourLight = colours.GreenLight;
             }
         }
 
-        private class ButtonWithTrianglesExposed : ReadyButton
+        protected override void Dispose(bool isDisposing)
         {
-            public new Triangles Triangles => base.Triangles;
+            base.Dispose(isDisposing);
+
+            if (multiplayerClient != null)
+                multiplayerClient.RoomUpdated -= onRoomUpdated;
+        }
+
+        public override LocalisableString TooltipText
+        {
+            get
+            {
+                if (room?.Countdown != null && multiplayerClient.IsHost && multiplayerClient.LocalUser?.State == MultiplayerUserState.Ready)
+                    return "Cancel countdown";
+
+                return base.TooltipText;
+            }
         }
     }
 }
diff --git a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
index 6dc5159b6f..9be1b18062 100644
--- a/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
+++ b/osu.Game/Tests/Visual/Multiplayer/TestMultiplayerClient.cs
@@ -7,12 +7,15 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Development;
 using osu.Framework.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.Countdown;
 using osu.Game.Online.Multiplayer.MatchTypes.TeamVersus;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets.Mods;
@@ -114,12 +117,24 @@ namespace osu.Game.Tests.Visual.Multiplayer
         public void ChangeUserState(int userId, MultiplayerUserState newState)
         {
             Debug.Assert(Room != null);
+
             ((IMultiplayerClient)this).UserStateChanged(userId, newState);
 
             Schedule(() =>
             {
                 switch (Room.State)
                 {
+                    case MultiplayerRoomState.Open:
+                        // If there are no remaining ready users or the host is not ready, stop any existing countdown.
+                        // Todo: When we have an "automatic start" mode, this should also start a new countdown if any users _are_ ready.
+                        // Todo: This doesn't yet support non-match-start countdowns.
+                        bool shouldStopCountdown = Room.Users.All(u => u.State != MultiplayerUserState.Ready);
+                        shouldStopCountdown |= Room.Host?.State != MultiplayerUserState.Ready && Room.Host?.State != MultiplayerUserState.Spectating;
+
+                        if (shouldStopCountdown)
+                            countdownStopSource?.Cancel();
+                        break;
+
                     case MultiplayerRoomState.WaitingForLoad:
                         if (Room.Users.All(u => u.State != MultiplayerUserState.WaitingForLoad))
                         {
@@ -282,6 +297,16 @@ namespace osu.Game.Tests.Visual.Multiplayer
             return Task.CompletedTask;
         }
 
+        private CancellationTokenSource? countdownSkipSource;
+        private CancellationTokenSource? countdownStopSource;
+        private Task countdownTask = Task.CompletedTask;
+
+        /// <summary>
+        /// Skips to the end of the currently-running countdown, if one is running,
+        /// and runs the callback (e.g. to start the match) as soon as possible unless the countdown has been cancelled.
+        /// </summary>
+        public void SkipToEndOfCountdown() => countdownSkipSource?.Cancel();
+
         public override async Task SendMatchRequest(MatchUserRequest request)
         {
             Debug.Assert(Room != null);
@@ -289,6 +314,67 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             switch (request)
             {
+                case StartMatchCountdownRequest matchCountdownRequest:
+                    Debug.Assert(ThreadSafety.IsUpdateThread);
+
+                    countdownStopSource?.Cancel();
+
+                    // Note that this will leak CTSs, however this is a test method and we haven't noticed foregoing disposal of non-linked CTSs to be detrimental.
+                    // If necessary, this can be moved into the final schedule below, and the class-level fields be nulled out accordingly.
+                    var stopSource = countdownStopSource = new CancellationTokenSource();
+                    var skipSource = countdownSkipSource = new CancellationTokenSource();
+                    var countdown = new MatchStartCountdown { TimeRemaining = matchCountdownRequest.Duration };
+
+                    Task lastCountdownTask = countdownTask;
+                    countdownTask = start();
+
+                    async Task start()
+                    {
+                        await lastCountdownTask;
+
+                        Schedule(() =>
+                        {
+                            if (stopSource.IsCancellationRequested)
+                                return;
+
+                            Room.Countdown = countdown;
+                            MatchEvent(new CountdownChangedEvent { Countdown = countdown });
+                        });
+
+                        try
+                        {
+                            using (var cancellationSource = CancellationTokenSource.CreateLinkedTokenSource(stopSource.Token, skipSource.Token))
+                                await Task.Delay(matchCountdownRequest.Duration, cancellationSource.Token).ConfigureAwait(false);
+                        }
+                        catch (OperationCanceledException)
+                        {
+                            // Clients need to be notified of cancellations in the following code.
+                        }
+
+                        Schedule(() =>
+                        {
+                            if (Room.Countdown != countdown)
+                                return;
+
+                            Room.Countdown = null;
+                            MatchEvent(new CountdownChangedEvent { Countdown = null });
+
+                            if (stopSource.IsCancellationRequested)
+                                return;
+
+                            StartMatch().WaitSafely();
+                        });
+                    }
+
+                    break;
+
+                case StopCountdownRequest _:
+                    countdownStopSource?.Cancel();
+
+                    Room.Countdown = null;
+                    await MatchEvent(new CountdownChangedEvent { Countdown = Room.Countdown });
+                    break;
+
                 case ChangeTeamRequest changeTeam:
 
                     TeamVersusRoomState roomState = (TeamVersusRoomState)Room.MatchState!;