diff --git a/osu.Game/Overlays/MusicController.cs b/osu.Game/Overlays/MusicController.cs
index 971503ca8b..c6c46da760 100644
--- a/osu.Game/Overlays/MusicController.cs
+++ b/osu.Game/Overlays/MusicController.cs
@@ -74,6 +74,7 @@ namespace osu.Game.Overlays
         private readonly Bindable<RandomSelectAlgorithm> randomSelectAlgorithm = new Bindable<RandomSelectAlgorithm>();
         private readonly List<Live<BeatmapSetInfo>> previousRandomSets = new List<Live<BeatmapSetInfo>>();
         private int randomHistoryDirection;
+        private int lastRandomTrackDirection;
 
         [BackgroundDependencyLoader]
         private void load(AudioManager audio, OsuConfigManager configManager)
@@ -371,54 +372,69 @@ namespace osu.Game.Overlays
 
         private Live<BeatmapSetInfo>? getNextRandom(int direction, bool allowProtectedTracks)
         {
-            Live<BeatmapSetInfo> result;
-
-            var possibleSets = getBeatmapSets().Where(s => !s.Value.Protected || allowProtectedTracks).ToArray();
-
-            if (possibleSets.Length == 0)
-                return null;
-
-            // condition below checks if the signs of `randomHistoryDirection` and `direction` are opposite and not zero.
-            // if that is the case, it means that the user had previously chosen next track `randomHistoryDirection` times and wants to go back,
-            // or that the user had previously chosen previous track `randomHistoryDirection` times and wants to go forward.
-            // in both cases, it means that we have a history of previous random selections that we can rewind.
-            if (randomHistoryDirection * direction < 0)
+            try
             {
-                Debug.Assert(Math.Abs(randomHistoryDirection) == previousRandomSets.Count);
-                result = previousRandomSets[^1];
-                previousRandomSets.RemoveAt(previousRandomSets.Count - 1);
-                randomHistoryDirection += direction;
-                return result;
-            }
+                Live<BeatmapSetInfo> result;
 
-            // if the early-return above didn't cover it, it means that we have no history to fall back on
-            // and need to actually choose something random.
-            switch (randomSelectAlgorithm.Value)
-            {
-                case RandomSelectAlgorithm.Random:
-                    result = possibleSets[RNG.Next(possibleSets.Length)];
-                    break;
+                var possibleSets = getBeatmapSets().Where(s => !s.Value.Protected || allowProtectedTracks).ToArray();
 
-                case RandomSelectAlgorithm.RandomPermutation:
-                    var notYetPlayedSets = possibleSets.Except(previousRandomSets).ToArray();
+                if (possibleSets.Length == 0)
+                    return null;
 
-                    if (notYetPlayedSets.Length == 0)
+                // condition below checks if the signs of `randomHistoryDirection` and `direction` are opposite and not zero.
+                // if that is the case, it means that the user had previously chosen next track `randomHistoryDirection` times and wants to go back,
+                // or that the user had previously chosen previous track `randomHistoryDirection` times and wants to go forward.
+                // in both cases, it means that we have a history of previous random selections that we can rewind.
+                if (randomHistoryDirection * direction < 0)
+                {
+                    Debug.Assert(Math.Abs(randomHistoryDirection) == previousRandomSets.Count);
+
+                    // if the user has been shuffling backwards and now going forwards (or vice versa),
+                    // the topmost item from history needs to be discarded because it's the *current* track.
+                    if (direction * lastRandomTrackDirection < 0)
                     {
-                        notYetPlayedSets = possibleSets;
-                        previousRandomSets.Clear();
-                        randomHistoryDirection = 0;
+                        previousRandomSets.RemoveAt(previousRandomSets.Count - 1);
+                        randomHistoryDirection += direction;
                     }
 
-                    result = notYetPlayedSets[RNG.Next(notYetPlayedSets.Length)];
-                    break;
+                    result = previousRandomSets[^1];
+                    previousRandomSets.RemoveAt(previousRandomSets.Count - 1);
+                    return result;
+                }
 
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(randomSelectAlgorithm), randomSelectAlgorithm.Value, "Unsupported random select algorithm");
+                // if the early-return above didn't cover it, it means that we have no history to fall back on
+                // and need to actually choose something random.
+                switch (randomSelectAlgorithm.Value)
+                {
+                    case RandomSelectAlgorithm.Random:
+                        result = possibleSets[RNG.Next(possibleSets.Length)];
+                        break;
+
+                    case RandomSelectAlgorithm.RandomPermutation:
+                        var notYetPlayedSets = possibleSets.Except(previousRandomSets).ToArray();
+
+                        if (notYetPlayedSets.Length == 0)
+                        {
+                            notYetPlayedSets = possibleSets;
+                            previousRandomSets.Clear();
+                            randomHistoryDirection = 0;
+                        }
+
+                        result = notYetPlayedSets[RNG.Next(notYetPlayedSets.Length)];
+                        break;
+
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(randomSelectAlgorithm), randomSelectAlgorithm.Value, "Unsupported random select algorithm");
+                }
+
+                previousRandomSets.Add(result);
+                return result;
+            }
+            finally
+            {
+                randomHistoryDirection += direction;
+                lastRandomTrackDirection = direction;
             }
-
-            previousRandomSets.Add(result);
-            randomHistoryDirection += direction;
-            return result;
         }
 
         private void restartTrack()