diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapConversionTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapConversionTest.cs
index 6b95975059..51c7ba029a 100644
--- a/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapConversionTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaBeatmapConversionTest.cs
@@ -35,11 +35,37 @@ namespace osu.Game.Rulesets.Mania.Tests
             };
         }
 
-        protected override ManiaConvertMapping CreateConvertMapping() => new ManiaConvertMapping(Converter);
+        private readonly Dictionary<HitObject, RngSnapshot> rngSnapshots = new Dictionary<HitObject, RngSnapshot>();
+
+        protected override void OnConversionGenerated(HitObject original, IEnumerable<HitObject> result, IBeatmapConverter beatmapConverter)
+        {
+            base.OnConversionGenerated(original, result, beatmapConverter);
+
+            rngSnapshots[original] = new RngSnapshot(beatmapConverter);
+        }
+
+        protected override ManiaConvertMapping CreateConvertMapping(HitObject source) => new ManiaConvertMapping(rngSnapshots[source]);
 
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }
 
+    public class RngSnapshot
+    {
+        public readonly uint RandomW;
+        public readonly uint RandomX;
+        public readonly uint RandomY;
+        public readonly uint RandomZ;
+
+        public RngSnapshot(IBeatmapConverter converter)
+        {
+            var maniaConverter = (ManiaBeatmapConverter)converter;
+            RandomW = maniaConverter.Random.W;
+            RandomX = maniaConverter.Random.X;
+            RandomY = maniaConverter.Random.Y;
+            RandomZ = maniaConverter.Random.Z;
+        }
+    }
+
     public class ManiaConvertMapping : ConvertMapping<ConvertValue>, IEquatable<ManiaConvertMapping>
     {
         public uint RandomW;
@@ -51,13 +77,12 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
         }
 
-        public ManiaConvertMapping(IBeatmapConverter converter)
+        public ManiaConvertMapping(RngSnapshot snapshot)
         {
-            var maniaConverter = (ManiaBeatmapConverter)converter;
-            RandomW = maniaConverter.Random.W;
-            RandomX = maniaConverter.Random.X;
-            RandomY = maniaConverter.Random.Y;
-            RandomZ = maniaConverter.Random.Z;
+            RandomW = snapshot.RandomW;
+            RandomX = snapshot.RandomX;
+            RandomY = snapshot.RandomY;
+            RandomZ = snapshot.RandomZ;
         }
 
         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index baf921ddfc..6b3a21a2c1 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -89,6 +89,14 @@ namespace osu.Game.Beatmaps
             return path;
         }
 
+        /// <summary>
+        /// Creates a <see cref="IBeatmapConverter"/> to convert a <see cref="IBeatmap"/> for a specified <see cref="Ruleset"/>.
+        /// </summary>
+        /// <param name="beatmap">The <see cref="IBeatmap"/> to be converted.</param>
+        /// <param name="ruleset">The <see cref="Ruleset"/> for which <paramref name="beatmap"/> should be converted.</param>
+        /// <returns>The applicable <see cref="IBeatmapConverter"/>.</returns>
+        protected virtual IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) => ruleset.CreateBeatmapConverter(beatmap);
+
         /// <summary>
         /// Constructs a playable <see cref="IBeatmap"/> from <see cref="Beatmap"/> using the applicable converters for a specific <see cref="RulesetInfo"/>.
         /// <para>
@@ -104,7 +112,7 @@ namespace osu.Game.Beatmaps
         {
             var rulesetInstance = ruleset.CreateInstance();
 
-            IBeatmapConverter converter = rulesetInstance.CreateBeatmapConverter(Beatmap);
+            IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
 
             // Check if the beatmap can be converted
             if (!converter.CanConvert)
diff --git a/osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs b/osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs
index 6a5e17eb38..1f2d457624 100644
--- a/osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs
+++ b/osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs
@@ -4,13 +4,16 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using Newtonsoft.Json;
 using NUnit.Framework;
-using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics.Textures;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Tests.Beatmaps
@@ -25,8 +28,6 @@ namespace osu.Game.Tests.Beatmaps
 
         protected abstract string ResourceAssembly { get; }
 
-        protected IBeatmapConverter Converter { get; private set; }
-
         protected void Test(string name)
         {
             var ourResult = convert(name);
@@ -98,26 +99,33 @@ namespace osu.Game.Tests.Beatmaps
             var rulesetInstance = CreateRuleset();
             beatmap.BeatmapInfo.Ruleset = beatmap.BeatmapInfo.RulesetID == rulesetInstance.RulesetInfo.ID ? rulesetInstance.RulesetInfo : new RulesetInfo();
 
-            Converter = rulesetInstance.CreateBeatmapConverter(beatmap);
+            var converterResult = new Dictionary<HitObject, IEnumerable<HitObject>>();
 
-            var result = new ConvertResult();
-
-            Converter.ObjectConverted += (orig, converted) =>
+            var working = new ConversionWorkingBeatmap(beatmap)
             {
-                converted.ForEach(h => h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty));
-
-                var mapping = CreateConvertMapping();
-                mapping.StartTime = orig.StartTime;
-
-                foreach (var obj in converted)
-                    mapping.Objects.AddRange(CreateConvertValue(obj));
-                result.Mappings.Add(mapping);
+                ConversionGenerated = (o, r, c) =>
+                {
+                    converterResult[o] = r;
+                    OnConversionGenerated(o, r, c);
+                }
             };
 
-            IBeatmap convertedBeatmap = Converter.Convert();
-            rulesetInstance.CreateBeatmapProcessor(convertedBeatmap)?.PostProcess();
+            working.GetPlayableBeatmap(rulesetInstance.RulesetInfo, Array.Empty<Mod>());
 
-            return result;
+            return new ConvertResult
+            {
+                Mappings = converterResult.Select(r =>
+                {
+                    var mapping = CreateConvertMapping(r.Key);
+                    mapping.StartTime = r.Key.StartTime;
+                    mapping.Objects.AddRange(r.Value.SelectMany(CreateConvertValue));
+                    return mapping;
+                }).ToList()
+            };
+        }
+
+        protected virtual void OnConversionGenerated(HitObject original, IEnumerable<HitObject> result, IBeatmapConverter beatmapConverter)
+        {
         }
 
         private ConvertResult read(string name)
@@ -154,7 +162,7 @@ namespace osu.Game.Tests.Beatmaps
         /// This should be used to validate the integrity of the conversion process after a conversion has occurred.
         /// </para>
         /// </summary>
-        protected virtual TConvertMapping CreateConvertMapping() => new TConvertMapping();
+        protected virtual TConvertMapping CreateConvertMapping(HitObject source) => new TConvertMapping();
 
         /// <summary>
         /// Creates the conversion value for a <see cref="HitObject"/>. A conversion value stores information about the converted <see cref="HitObject"/>.
@@ -176,6 +184,32 @@ namespace osu.Game.Tests.Beatmaps
             [JsonProperty]
             public List<TConvertMapping> Mappings = new List<TConvertMapping>();
         }
+
+        private class ConversionWorkingBeatmap : WorkingBeatmap
+        {
+            public Action<HitObject, IEnumerable<HitObject>, IBeatmapConverter> ConversionGenerated;
+
+            private readonly IBeatmap beatmap;
+
+            public ConversionWorkingBeatmap(IBeatmap beatmap)
+                : base(beatmap.BeatmapInfo, null)
+            {
+                this.beatmap = beatmap;
+            }
+
+            protected override IBeatmap GetBeatmap() => beatmap;
+
+            protected override Texture GetBackground() => throw new NotImplementedException();
+
+            protected override Track GetTrack() => throw new NotImplementedException();
+
+            protected override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
+            {
+                var converter = base.CreateBeatmapConverter(beatmap, ruleset);
+                converter.ObjectConverted += (orig, converted) => ConversionGenerated?.Invoke(orig, converted, converter);
+                return converter;
+            }
+        }
     }
 
     public abstract class BeatmapConversionTest<TConvertValue> : BeatmapConversionTest<ConvertMapping<TConvertValue>, TConvertValue>