diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderSelectionBlueprint.cs
index 5df0b70f12..dde2aa53e0 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSliderSelectionBlueprint.cs
@@ -16,6 +16,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -85,6 +86,93 @@ namespace osu.Game.Rulesets.Osu.Tests
             checkPositions();
         }
 
+        [Test]
+        public void TestSingleControlPointSelection()
+        {
+            moveMouseToControlPoint(0);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            checkControlPointSelected(0, true);
+            checkControlPointSelected(1, false);
+        }
+
+        [Test]
+        public void TestSingleControlPointDeselectionViaOtherControlPoint()
+        {
+            moveMouseToControlPoint(0);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            moveMouseToControlPoint(1);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            checkControlPointSelected(0, false);
+            checkControlPointSelected(1, true);
+        }
+
+        [Test]
+        public void TestSingleControlPointDeselectionViaClickOutside()
+        {
+            moveMouseToControlPoint(0);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move mouse outside control point", () => InputManager.MoveMouseTo(drawableObject));
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            checkControlPointSelected(0, false);
+            checkControlPointSelected(1, false);
+        }
+
+        [Test]
+        public void TestMultipleControlPointSelection()
+        {
+            moveMouseToControlPoint(0);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            moveMouseToControlPoint(1);
+            AddStep("ctrl + click", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+            checkControlPointSelected(0, true);
+            checkControlPointSelected(1, true);
+        }
+
+        [Test]
+        public void TestMultipleControlPointDeselectionViaOtherControlPoint()
+        {
+            moveMouseToControlPoint(0);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            moveMouseToControlPoint(1);
+            AddStep("ctrl + click", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            moveMouseToControlPoint(2);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            checkControlPointSelected(0, false);
+            checkControlPointSelected(1, false);
+        }
+
+        [Test]
+        public void TestMultipleControlPointDeselectionViaClickOutside()
+        {
+            moveMouseToControlPoint(0);
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            moveMouseToControlPoint(1);
+            AddStep("ctrl + click", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+
+            AddStep("move mouse outside control point", () => InputManager.MoveMouseTo(drawableObject));
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            checkControlPointSelected(0, false);
+            checkControlPointSelected(1, false);
+        }
+
         private void moveHitObject()
         {
             AddStep("move hitobject", () =>
@@ -104,11 +192,24 @@ namespace osu.Game.Rulesets.Osu.Tests
                 () => Precision.AlmostEquals(blueprint.TailBlueprint.CirclePiece.ScreenSpaceDrawQuad.Centre, drawableObject.TailCircle.ScreenSpaceDrawQuad.Centre));
         }
 
+        private void moveMouseToControlPoint(int index)
+        {
+            AddStep($"move mouse to control point {index}", () =>
+            {
+                Vector2 position = slider.Position + slider.Path.ControlPoints[index];
+                InputManager.MoveMouseTo(drawableObject.Parent.ToScreenSpace(position));
+            });
+        }
+
+        private void checkControlPointSelected(int index, bool selected)
+            => AddAssert($"control point {index} {(selected ? "selected" : "not selected")}", () => blueprint.ControlPointVisualiser.Pieces[index].IsSelected.Value == selected);
+
         private class TestSliderBlueprint : SliderSelectionBlueprint
         {
             public new SliderBodyPiece BodyPiece => base.BodyPiece;
             public new TestSliderCircleBlueprint HeadBlueprint => (TestSliderCircleBlueprint)base.HeadBlueprint;
             public new TestSliderCircleBlueprint TailBlueprint => (TestSliderCircleBlueprint)base.TailBlueprint;
+            public new PathControlPointVisualiser ControlPointVisualiser => base.ControlPointVisualiser;
 
             public TestSliderBlueprint(DrawableSlider slider)
                 : base(slider)
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
index 7afb8fcf49..e2ea6a12d7 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs
@@ -3,6 +3,7 @@
 
 using System;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Lines;
@@ -11,18 +12,24 @@ using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class PathControlPointPiece : BlueprintPiece<Slider>
     {
+        public Action<int> RequestSelection;
         public Action<Vector2[]> ControlPointsChanged;
 
-        private readonly Slider slider;
-        private readonly int index;
+        public readonly BindableBool IsSelected = new BindableBool();
+        public readonly int Index;
 
+        private readonly Slider slider;
         private readonly Path path;
-        private readonly CircularContainer marker;
+        private readonly Container marker;
+        private readonly Drawable markerRing;
+
+        private bool isClicked;
 
         [Resolved]
         private OsuColour colours { get; set; }
@@ -30,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         public PathControlPointPiece(Slider slider, int index)
         {
             this.slider = slider;
-            this.index = index;
+            Index = index;
 
             Origin = Anchor.Centre;
             AutoSizeAxes = Axes.Both;
@@ -42,13 +49,36 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                     Anchor = Anchor.Centre,
                     PathRadius = 1
                 },
-                marker = new CircularContainer
+                marker = new Container
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(10),
-                    Masking = true,
-                    Child = new Box { RelativeSizeAxes = Axes.Both }
+                    AutoSizeAxes = Axes.Both,
+                    Children = new[]
+                    {
+                        new Circle
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(10),
+                        },
+                        markerRing = new CircularContainer
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Size = new Vector2(14),
+                            Masking = true,
+                            BorderThickness = 2,
+                            BorderColour = Color4.White,
+                            Alpha = 0,
+                            Child = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                AlwaysPresent = true
+                            }
+                        }
+                    }
                 }
             };
         }
@@ -57,30 +87,69 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         {
             base.Update();
 
-            Position = slider.StackedPosition + slider.Path.ControlPoints[index];
+            Position = slider.StackedPosition + slider.Path.ControlPoints[Index];
 
-            marker.Colour = isSegmentSeparator ? colours.Red : colours.Yellow;
+            updateMarkerDisplay();
+            updateConnectingPath();
+        }
 
+        /// <summary>
+        /// Updates the state of the circular control point marker.
+        /// </summary>
+        private void updateMarkerDisplay()
+        {
+            markerRing.Alpha = IsSelected.Value ? 1 : 0;
+
+            Color4 colour = isSegmentSeparator ? colours.Red : colours.Yellow;
+            if (IsHovered || isClicked || IsSelected.Value)
+                colour = Color4.White;
+            marker.Colour = colour;
+        }
+
+        /// <summary>
+        /// Updates the path connecting this control point to the previous one.
+        /// </summary>
+        private void updateConnectingPath()
+        {
             path.ClearVertices();
 
-            if (index != slider.Path.ControlPoints.Length - 1)
+            if (Index != slider.Path.ControlPoints.Length - 1)
             {
                 path.AddVertex(Vector2.Zero);
-                path.AddVertex(slider.Path.ControlPoints[index + 1] - slider.Path.ControlPoints[index]);
+                path.AddVertex(slider.Path.ControlPoints[Index + 1] - slider.Path.ControlPoints[Index]);
             }
 
             path.OriginPosition = path.PositionInBoundingBox(Vector2.Zero);
         }
 
+        // The connecting path is excluded from positional input
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => marker.ReceivePositionalInputAt(screenSpacePos);
 
+        protected override bool OnMouseDown(MouseDownEvent e)
+        {
+            isClicked = true;
+            return true;
+        }
+
+        protected override bool OnMouseUp(MouseUpEvent e)
+        {
+            isClicked = false;
+            return true;
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            RequestSelection?.Invoke(Index);
+            return true;
+        }
+
         protected override bool OnDragStart(DragStartEvent e) => true;
 
         protected override bool OnDrag(DragEvent e)
         {
             var newControlPoints = slider.Path.ControlPoints.ToArray();
 
-            if (index == 0)
+            if (Index == 0)
             {
                 // Special handling for the head - only the position of the slider changes
                 slider.Position += e.Delta;
@@ -90,13 +159,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                     newControlPoints[i] -= e.Delta;
             }
             else
-                newControlPoints[index] += e.Delta;
+                newControlPoints[Index] += e.Delta;
 
             if (isSegmentSeparatorWithNext)
-                newControlPoints[index + 1] = newControlPoints[index];
+                newControlPoints[Index + 1] = newControlPoints[Index];
 
             if (isSegmentSeparatorWithPrevious)
-                newControlPoints[index - 1] = newControlPoints[index];
+                newControlPoints[Index - 1] = newControlPoints[Index];
 
             ControlPointsChanged?.Invoke(newControlPoints);
 
@@ -107,8 +176,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
         private bool isSegmentSeparator => isSegmentSeparatorWithNext || isSegmentSeparatorWithPrevious;
 
-        private bool isSegmentSeparatorWithNext => index < slider.Path.ControlPoints.Length - 1 && slider.Path.ControlPoints[index + 1] == slider.Path.ControlPoints[index];
+        private bool isSegmentSeparatorWithNext => Index < slider.Path.ControlPoints.Length - 1 && slider.Path.ControlPoints[Index + 1] == slider.Path.ControlPoints[Index];
 
-        private bool isSegmentSeparatorWithPrevious => index > 0 && slider.Path.ControlPoints[index - 1] == slider.Path.ControlPoints[index];
+        private bool isSegmentSeparatorWithPrevious => Index > 0 && slider.Path.ControlPoints[Index - 1] == slider.Path.ControlPoints[Index];
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
index 0385824b27..b70c11427a 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
@@ -4,6 +4,8 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 
@@ -13,25 +15,60 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
     {
         public Action<Vector2[]> ControlPointsChanged;
 
+        internal readonly Container<PathControlPointPiece> Pieces;
         private readonly Slider slider;
 
-        private readonly Container<PathControlPointPiece> pieces;
+        private InputManager inputManager;
 
         public PathControlPointVisualiser(Slider slider)
         {
             this.slider = slider;
 
-            InternalChild = pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both };
+            RelativeSizeAxes = Axes.Both;
+
+            InternalChild = Pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            inputManager = GetContainingInputManager();
         }
 
         protected override void Update()
         {
             base.Update();
 
-            while (slider.Path.ControlPoints.Length > pieces.Count)
-                pieces.Add(new PathControlPointPiece(slider, pieces.Count) { ControlPointsChanged = c => ControlPointsChanged?.Invoke(c) });
-            while (slider.Path.ControlPoints.Length < pieces.Count)
-                pieces.Remove(pieces[pieces.Count - 1]);
+            while (slider.Path.ControlPoints.Length > Pieces.Count)
+            {
+                Pieces.Add(new PathControlPointPiece(slider, Pieces.Count)
+                {
+                    ControlPointsChanged = c => ControlPointsChanged?.Invoke(c),
+                    RequestSelection = selectPiece
+                });
+            }
+
+            while (slider.Path.ControlPoints.Length < Pieces.Count)
+                Pieces.Remove(Pieces[Pieces.Count - 1]);
+        }
+
+        protected override bool OnClick(ClickEvent e)
+        {
+            foreach (var piece in Pieces)
+                piece.IsSelected.Value = false;
+            return false;
+        }
+
+        private void selectPiece(int index)
+        {
+            if (inputManager.CurrentState.Keyboard.ControlPressed)
+                Pieces[index].IsSelected.Toggle();
+            else
+            {
+                foreach (var piece in Pieces)
+                    piece.IsSelected.Value = piece.Index == index;
+            }
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
index b09f598bcc..f612ba9dfc 100644
--- a/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
+++ b/osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs
@@ -18,6 +18,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         protected readonly SliderBodyPiece BodyPiece;
         protected readonly SliderCircleSelectionBlueprint HeadBlueprint;
         protected readonly SliderCircleSelectionBlueprint TailBlueprint;
+        protected readonly PathControlPointVisualiser ControlPointVisualiser;
 
         [Resolved(CanBeNull = true)]
         private HitObjectComposer composer { get; set; }
@@ -32,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 BodyPiece = new SliderBodyPiece(),
                 HeadBlueprint = CreateCircleSelectionBlueprint(slider, SliderPosition.Start),
                 TailBlueprint = CreateCircleSelectionBlueprint(slider, SliderPosition.End),
-                new PathControlPointVisualiser(sliderObject) { ControlPointsChanged = onNewControlPoints },
+                ControlPointVisualiser = new PathControlPointVisualiser(sliderObject) { ControlPointsChanged = onNewControlPoints },
             };
         }
 
@@ -49,6 +50,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             var snappedDistance = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)unsnappedPath.Distance) ?? (float)unsnappedPath.Distance;
 
             HitObject.Path = new SliderPath(unsnappedPath.Type, controlPoints, snappedDistance);
+
+            UpdateHitObject();
         }
 
         public override Vector2 SelectionPoint => HeadBlueprint.SelectionPoint;
diff --git a/osu.Game.Rulesets.Osu/Objects/Slider.cs b/osu.Game.Rulesets.Osu/Objects/Slider.cs
index 010bf072e8..f60b7e67b2 100644
--- a/osu.Game.Rulesets.Osu/Objects/Slider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Slider.cs
@@ -37,6 +37,8 @@ namespace osu.Game.Rulesets.Osu.Objects
             {
                 PathBindable.Value = value;
                 endPositionCache.Invalidate();
+
+                updateNestedPositions();
             }
         }
 
@@ -48,14 +50,9 @@ namespace osu.Game.Rulesets.Osu.Objects
             set
             {
                 base.Position = value;
-
                 endPositionCache.Invalidate();
 
-                if (HeadCircle != null)
-                    HeadCircle.Position = value;
-
-                if (TailCircle != null)
-                    TailCircle.Position = EndPosition;
+                updateNestedPositions();
             }
         }
 
@@ -197,6 +194,15 @@ namespace osu.Game.Rulesets.Osu.Objects
             }
         }
 
+        private void updateNestedPositions()
+        {
+            if (HeadCircle != null)
+                HeadCircle.Position = Position;
+
+            if (TailCircle != null)
+                TailCircle.Position = EndPosition;
+        }
+
         private List<HitSampleInfo> getNodeSamples(int nodeIndex) =>
             nodeIndex < NodeSamples.Count ? NodeSamples[nodeIndex] : Samples;
 
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayDownloadButton.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayDownloadButton.cs
index 0dfcda122f..7b22fedbd5 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneReplayDownloadButton.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneReplayDownloadButton.cs
@@ -7,11 +7,10 @@ using osu.Game.Online;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Scoring;
-using osu.Game.Screens.Play;
 using osu.Game.Users;
-using osuTK;
 using System;
 using System.Collections.Generic;
+using osu.Game.Screens.Ranking.Pages;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
@@ -42,7 +41,6 @@ namespace osu.Game.Tests.Visual.Gameplay
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(80, 40),
                 };
             });
         }
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneResults.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneResults.cs
index f3c8f89db7..bf26892539 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneResults.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneResults.cs
@@ -22,10 +22,11 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(ScoreInfo),
             typeof(Results),
             typeof(ResultsPage),
             typeof(ScoreResultsPage),
+            typeof(RetryButton),
+            typeof(ReplayDownloadButton),
             typeof(LocalLeaderboardPage)
         };
 
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index 5922bfba78..1c942e52ce 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -148,7 +148,7 @@ namespace osu.Game.Rulesets.Edit
             EditorBeatmap = new EditorBeatmap<TObject>(playableBeatmap);
             EditorBeatmap.HitObjectAdded += addHitObject;
             EditorBeatmap.HitObjectRemoved += removeHitObject;
-            EditorBeatmap.StartTimeChanged += updateHitObject;
+            EditorBeatmap.StartTimeChanged += UpdateHitObject;
 
             var dependencies = new DependencyContainer(parent);
             dependencies.CacheAs<IEditorBeatmap>(EditorBeatmap);
@@ -225,11 +225,7 @@ namespace osu.Game.Rulesets.Edit
 
         private ScheduledDelegate scheduledUpdate;
 
-        private void addHitObject(HitObject hitObject) => updateHitObject(hitObject);
-
-        private void removeHitObject(HitObject hitObject) => updateHitObject(null);
-
-        private void updateHitObject([CanBeNull] HitObject hitObject)
+        public override void UpdateHitObject(HitObject hitObject)
         {
             scheduledUpdate?.Cancel();
             scheduledUpdate = Schedule(() =>
@@ -240,6 +236,10 @@ namespace osu.Game.Rulesets.Edit
             });
         }
 
+        private void addHitObject(HitObject hitObject) => UpdateHitObject(hitObject);
+
+        private void removeHitObject(HitObject hitObject) => UpdateHitObject(null);
+
         public override IEnumerable<DrawableHitObject> HitObjects => drawableRulesetWrapper.Playfield.AllHitObjects;
         public override bool CursorInPlacementArea => drawableRulesetWrapper.Playfield.ReceivePositionalInputAt(inputManager.CurrentState.Mouse.Position);
 
@@ -351,11 +351,22 @@ namespace osu.Game.Rulesets.Edit
         [CanBeNull]
         protected virtual DistanceSnapGrid CreateDistanceSnapGrid([NotNull] IEnumerable<HitObject> selectedHitObjects) => null;
 
+        /// <summary>
+        /// Updates a <see cref="HitObject"/>, invoking <see cref="HitObject.ApplyDefaults"/> and re-processing the beatmap.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> to update.</param>
+        public abstract void UpdateHitObject([CanBeNull] HitObject hitObject);
+
         public abstract (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time);
+
         public abstract float GetBeatSnapDistanceAt(double referenceTime);
+
         public abstract float DurationToDistance(double referenceTime, double duration);
+
         public abstract double DistanceToDuration(double referenceTime, float distance);
+
         public abstract double GetSnappedDurationFromDistance(double referenceTime, float distance);
+
         public abstract float GetSnappedDistanceFromDistance(double referenceTime, float distance);
     }
 }
diff --git a/osu.Game/Rulesets/Edit/SelectionBlueprint.cs b/osu.Game/Rulesets/Edit/SelectionBlueprint.cs
index 44f38acfd4..0701513933 100644
--- a/osu.Game/Rulesets/Edit/SelectionBlueprint.cs
+++ b/osu.Game/Rulesets/Edit/SelectionBlueprint.cs
@@ -3,10 +3,12 @@
 
 using System;
 using osu.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
 
@@ -36,6 +38,9 @@ namespace osu.Game.Rulesets.Edit
         public override bool HandlePositionalInput => ShouldBeAlive;
         public override bool RemoveWhenNotAlive => false;
 
+        [Resolved(CanBeNull = true)]
+        private HitObjectComposer composer { get; set; }
+
         protected SelectionBlueprint(DrawableHitObject drawableObject)
         {
             DrawableObject = drawableObject;
@@ -89,6 +94,11 @@ namespace osu.Game.Rulesets.Edit
 
         public bool IsSelected => State == SelectionState.Selected;
 
+        /// <summary>
+        /// Updates the <see cref="HitObject"/>, invoking <see cref="HitObject.ApplyDefaults"/> and re-processing the beatmap.
+        /// </summary>
+        protected void UpdateHitObject() => composer?.UpdateHitObject(DrawableObject.HitObject);
+
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => DrawableObject.ReceivePositionalInputAt(screenSpacePos);
 
         /// <summary>
diff --git a/osu.Game/Screens/Play/GameplayClockContainer.cs b/osu.Game/Screens/Play/GameplayClockContainer.cs
index 6a03271b86..f2efbe6073 100644
--- a/osu.Game/Screens/Play/GameplayClockContainer.cs
+++ b/osu.Game/Screens/Play/GameplayClockContainer.cs
@@ -8,6 +8,7 @@ using System.Threading.Tasks;
 using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -29,7 +30,7 @@ namespace osu.Game.Screens.Play
         /// <summary>
         /// The original source (usually a <see cref="WorkingBeatmap"/>'s track).
         /// </summary>
-        private readonly IAdjustableClock sourceClock;
+        private IAdjustableClock sourceClock;
 
         public readonly BindableBool IsPaused = new BindableBool();
 
@@ -153,6 +154,18 @@ namespace osu.Game.Screens.Play
             IsPaused.Value = true;
         }
 
+        /// <summary>
+        /// Changes the backing clock to avoid using the originally provided beatmap's track.
+        /// </summary>
+        public void StopUsingBeatmapClock()
+        {
+            if (sourceClock != beatmap.Track)
+                return;
+
+            sourceClock = new TrackVirtual(beatmap.Track.Length);
+            adjustableClock.ChangeSource(sourceClock);
+        }
+
         public void ResetLocalAdjustments()
         {
             // In the case of replays, we may have changed the playback rate.
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index 280ebca651..a3c39d9cc1 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -30,6 +30,7 @@ using osu.Game.Users;
 
 namespace osu.Game.Screens.Play
 {
+    [Cached]
     public class Player : ScreenWithBeatmapBackground
     {
         public override bool AllowBackButton => false; // handled by HoldForMenuButton
@@ -311,14 +312,19 @@ namespace osu.Game.Screens.Play
                 this.Exit();
         }
 
+        /// <summary>
+        /// Restart gameplay via a parent <see cref="PlayerLoader"/>.
+        /// <remarks>This can be called from a child screen in order to trigger the restart process.</remarks>
+        /// </summary>
         public void Restart()
         {
-            if (!this.IsCurrentScreen()) return;
-
             sampleRestart?.Play();
-
             RestartRequested?.Invoke();
-            performImmediateExit();
+
+            if (this.IsCurrentScreen())
+                performImmediateExit();
+            else
+                this.MakeCurrent();
         }
 
         private ScheduledDelegate completionProgressDelegate;
@@ -532,6 +538,10 @@ namespace osu.Game.Screens.Play
 
             GameplayClockContainer.ResetLocalAdjustments();
 
+            // GameplayClockContainer performs seeks / start / stop operations on the beatmap's track.
+            // as we are no longer the current screen, we cannot guarantee the track is still usable.
+            GameplayClockContainer.StopUsingBeatmapClock();
+
             fadeOut();
             return base.OnExiting(next);
         }
diff --git a/osu.Game/Screens/Play/ReplayDownloadButton.cs b/osu.Game/Screens/Ranking/Pages/ReplayDownloadButton.cs
similarity index 96%
rename from osu.Game/Screens/Play/ReplayDownloadButton.cs
rename to osu.Game/Screens/Ranking/Pages/ReplayDownloadButton.cs
index 290e00f287..73c647d6fa 100644
--- a/osu.Game/Screens/Play/ReplayDownloadButton.cs
+++ b/osu.Game/Screens/Ranking/Pages/ReplayDownloadButton.cs
@@ -4,12 +4,13 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Containers;
-using osu.Game.Online;
-using osu.Game.Scoring;
-using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Scoring;
+using osuTK;
 
-namespace osu.Game.Screens.Play
+namespace osu.Game.Screens.Ranking.Pages
 {
     public class ReplayDownloadButton : DownloadTrackingComposite<ScoreInfo, ScoreManager>
     {
@@ -33,6 +34,7 @@ namespace osu.Game.Screens.Play
         public ReplayDownloadButton(ScoreInfo score)
             : base(score)
         {
+            Size = new Vector2(50, 30);
         }
 
         [BackgroundDependencyLoader(true)]
diff --git a/osu.Game/Screens/Ranking/Pages/RetryButton.cs b/osu.Game/Screens/Ranking/Pages/RetryButton.cs
new file mode 100644
index 0000000000..2a281224c1
--- /dev/null
+++ b/osu.Game/Screens/Ranking/Pages/RetryButton.cs
@@ -0,0 +1,54 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Play;
+using osuTK;
+
+namespace osu.Game.Screens.Ranking.Pages
+{
+    public class RetryButton : OsuAnimatedButton
+    {
+        private readonly Box background;
+
+        [Resolved(canBeNull: true)]
+        private Player player { get; set; }
+
+        public RetryButton()
+        {
+            Size = new Vector2(50, 30);
+
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = float.MaxValue
+                },
+                new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(13),
+                    Icon = FontAwesome.Solid.ArrowCircleLeft,
+                },
+            };
+
+            TooltipText = "Retry";
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.Green;
+
+            if (player != null)
+                Action = () => player.Restart();
+        }
+    }
+}
diff --git a/osu.Game/Screens/Ranking/Pages/ScoreResultsPage.cs b/osu.Game/Screens/Ranking/Pages/ScoreResultsPage.cs
index 56ae069a26..27cea99f1c 100644
--- a/osu.Game/Screens/Ranking/Pages/ScoreResultsPage.cs
+++ b/osu.Game/Screens/Ranking/Pages/ScoreResultsPage.cs
@@ -169,12 +169,19 @@ namespace osu.Game.Screens.Ranking.Pages
                         },
                     },
                 },
-                new ReplayDownloadButton(score)
+                new FillFlowContainer
                 {
                     Anchor = Anchor.BottomCentre,
                     Origin = Anchor.BottomCentre,
                     Margin = new MarginPadding { Bottom = 10 },
-                    Size = new Vector2(50, 30),
+                    Spacing = new Vector2(5),
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Children = new Drawable[]
+                    {
+                        new ReplayDownloadButton(score),
+                        new RetryButton()
+                    }
                 },
             };
 
diff --git a/osu.Game/Screens/Ranking/Results.cs b/osu.Game/Screens/Ranking/Results.cs
index cac26b3dbf..3640197dad 100644
--- a/osu.Game/Screens/Ranking/Results.cs
+++ b/osu.Game/Screens/Ranking/Results.cs
@@ -19,6 +19,7 @@ using osu.Game.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 
 namespace osu.Game.Screens.Ranking
 {
@@ -34,6 +35,9 @@ namespace osu.Game.Screens.Ranking
 
         private ResultModeTabControl modeChangeButtons;
 
+        [Resolved(canBeNull: true)]
+        private Player player { get; set; }
+
         public override bool DisallowExternalBeatmapRulesetChanges => true;
 
         protected readonly ScoreInfo Score;
@@ -100,10 +104,7 @@ namespace osu.Game.Screens.Ranking
 
         public override bool OnExiting(IScreen next)
         {
-            allCircles.ForEach(c =>
-            {
-                c.ScaleTo(0, transition_time, Easing.OutSine);
-            });
+            allCircles.ForEach(c => c.ScaleTo(0, transition_time, Easing.OutSine));
 
             Background.ScaleTo(1f, transition_time / 4, Easing.OutQuint);
 
@@ -253,7 +254,16 @@ namespace osu.Game.Screens.Ranking
                             }
                         }
                     }
-                }
+                },
+                new HotkeyRetryOverlay
+                {
+                    Action = () =>
+                    {
+                        if (!this.IsCurrentScreen()) return;
+
+                        player?.Restart();
+                    },
+                },
             };
 
             var pages = CreateResultPages();
diff --git a/osu.Game/Tests/Visual/SelectionBlueprintTestScene.cs b/osu.Game/Tests/Visual/SelectionBlueprintTestScene.cs
index f53c12b047..3233ee160d 100644
--- a/osu.Game/Tests/Visual/SelectionBlueprintTestScene.cs
+++ b/osu.Game/Tests/Visual/SelectionBlueprintTestScene.cs
@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Edit;
 
 namespace osu.Game.Tests.Visual
 {
-    public abstract class SelectionBlueprintTestScene : OsuTestScene
+    public abstract class SelectionBlueprintTestScene : ManualInputManagerTestScene
     {
         protected override Container<Drawable> Content => content ?? base.Content;
         private readonly Container content;