diff --git a/src/Umbraco.Core/Models/AuditType.cs b/src/Umbraco.Core/Models/AuditType.cs
index cea6c7ccf286..b6a36be5ff03 100644
--- a/src/Umbraco.Core/Models/AuditType.cs
+++ b/src/Umbraco.Core/Models/AuditType.cs
@@ -113,6 +113,16 @@ public enum AuditType
         /// <summary>
         /// Custom audit message.
         /// </summary>
-        Custom
+        Custom,
+
+        /// <summary>
+        /// Content version preventCleanup set to true
+        /// </summary>
+        ContentVersionPreventCleanup,
+
+        /// <summary>
+        /// Content version preventCleanup set to false
+        /// </summary>
+        ContentVersionEnableCleanup
     }
 }
diff --git a/src/Umbraco.Core/Models/ContentVersionMeta.cs b/src/Umbraco.Core/Models/ContentVersionMeta.cs
new file mode 100644
index 000000000000..d2e53e0985d8
--- /dev/null
+++ b/src/Umbraco.Core/Models/ContentVersionMeta.cs
@@ -0,0 +1,45 @@
+using System;
+
+namespace Umbraco.Cms.Core.Models
+{
+    public class ContentVersionMeta
+    {
+        public int ContentId { get; }
+        public int ContentTypeId { get; }
+        public int VersionId { get; }
+        public int UserId { get; }
+
+        public DateTime VersionDate { get; }
+        public bool CurrentPublishedVersion { get; }
+        public bool CurrentDraftVersion { get; }
+        public bool PreventCleanup { get; }
+        public string Username { get; }
+
+        public ContentVersionMeta() { }
+
+        public ContentVersionMeta(
+            int versionId,
+            int contentId,
+            int contentTypeId,
+            int userId,
+            DateTime versionDate,
+            bool currentPublishedVersion,
+            bool currentDraftVersion,
+            bool preventCleanup,
+            string username)
+        {
+            VersionId = versionId;
+            ContentId = contentId;
+            ContentTypeId = contentTypeId;
+
+            UserId = userId;
+            VersionDate = versionDate;
+            CurrentPublishedVersion = currentPublishedVersion;
+            CurrentDraftVersion = currentDraftVersion;
+            PreventCleanup = preventCleanup;
+            Username = username;
+        }
+
+        public override string ToString() => $"ContentVersionMeta(versionId: {VersionId}, versionDate: {VersionDate:s}";
+    }
+}
diff --git a/src/Umbraco.Core/Models/HistoricContentVersionMeta.cs b/src/Umbraco.Core/Models/HistoricContentVersionMeta.cs
deleted file mode 100644
index ce2c771ec6bf..000000000000
--- a/src/Umbraco.Core/Models/HistoricContentVersionMeta.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-
-namespace Umbraco.Cms.Core.Models
-{
-    public class HistoricContentVersionMeta
-    {
-        public int ContentId { get; }
-        public int ContentTypeId { get; }
-        public int VersionId { get; }
-        public DateTime VersionDate { get; }
-
-        public HistoricContentVersionMeta() { }
-
-        public HistoricContentVersionMeta(int contentId, int contentTypeId, int versionId, DateTime versionDate)
-        {
-            ContentId = contentId;
-            ContentTypeId = contentTypeId;
-            VersionId = versionId;
-            VersionDate = versionDate;
-        }
-
-        public override string ToString() => $"HistoricContentVersionMeta(versionId: {VersionId}, versionDate: {VersionDate:s}";
-    }
-}
diff --git a/src/Umbraco.Core/Persistence/Repositories/IDocumentVersionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IDocumentVersionRepository.cs
index 8175ba0d99a3..38f425d5a19f 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IDocumentVersionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IDocumentVersionRepository.cs
@@ -8,16 +8,31 @@ public interface IDocumentVersionRepository : IRepository
         /// <summary>
         /// Gets a list of all historic content versions.
         /// </summary>
-        public IReadOnlyCollection<HistoricContentVersionMeta> GetDocumentVersionsEligibleForCleanup();
+        public IReadOnlyCollection<ContentVersionMeta> GetDocumentVersionsEligibleForCleanup();
 
         /// <summary>
         /// Gets cleanup policy override settings per content type.
         /// </summary>
         public IReadOnlyCollection<ContentVersionCleanupPolicySettings> GetCleanupPolicies();
 
+        /// <summary>
+        /// Gets paginated content versions for given content id paginated.
+        /// </summary>
+        public IEnumerable<ContentVersionMeta> GetPagedItemsByContentId(int contentId, long pageIndex, int pageSize, out long totalRecords, int? languageId = null);
+
         /// <summary>
         /// Deletes multiple content versions by ID.
         /// </summary>
         void DeleteVersions(IEnumerable<int> versionIds);
+
+        /// <summary>
+        /// Updates the prevent cleanup flag on a content version.
+        /// </summary>
+        void SetPreventCleanup(int versionId, bool preventCleanup);
+
+        /// <summary>
+        /// Gets the content version metadata for a specific version.
+        /// </summary>
+        ContentVersionMeta Get(int versionId);
     }
 }
diff --git a/src/Umbraco.Core/Services/IContentVersionCleanupPolicy.cs b/src/Umbraco.Core/Services/IContentVersionCleanupPolicy.cs
index d2f70206b087..86e298830749 100644
--- a/src/Umbraco.Core/Services/IContentVersionCleanupPolicy.cs
+++ b/src/Umbraco.Core/Services/IContentVersionCleanupPolicy.cs
@@ -12,6 +12,6 @@ public interface IContentVersionCleanupPolicy
         /// <summary>
         /// Filters a set of candidates historic content versions for cleanup according to policy settings.
         /// </summary>
-        IEnumerable<HistoricContentVersionMeta> Apply(DateTime asAtDate, IEnumerable<HistoricContentVersionMeta> items);
+        IEnumerable<ContentVersionMeta> Apply(DateTime asAtDate, IEnumerable<ContentVersionMeta> items);
     }
 }
diff --git a/src/Umbraco.Core/Services/IContentVersionService.cs b/src/Umbraco.Core/Services/IContentVersionService.cs
index 882618780fe6..1f56138c3d35 100644
--- a/src/Umbraco.Core/Services/IContentVersionService.cs
+++ b/src/Umbraco.Core/Services/IContentVersionService.cs
@@ -9,6 +9,17 @@ public interface IContentVersionService
         /// <summary>
         /// Removes historic content versions according to a policy.
         /// </summary>
-        IReadOnlyCollection<HistoricContentVersionMeta> PerformContentVersionCleanup(DateTime asAtDate);
+        IReadOnlyCollection<ContentVersionMeta> PerformContentVersionCleanup(DateTime asAtDate);
+
+        /// <summary>
+        /// Gets paginated content versions for given content id paginated.
+        /// </summary>
+        /// <exception cref="ArgumentException">Thrown when <paramref name="culture"/> is invalid.</exception>
+        IEnumerable<ContentVersionMeta> GetPagedContentVersions(int contentId, long pageIndex, int pageSize, out long totalRecords, string culture = null);
+
+        /// <summary>
+        /// Updates preventCleanup value for given content version.
+        /// </summary>
+        void SetPreventCleanup(int versionId, bool preventCleanup, int userId = -1);
     }
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentRepository.cs
index 12e094cd7cb7..ad9030dc4e3d 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentRepository.cs
@@ -630,6 +630,10 @@ protected override void PersistUpdatedItem(IContent entity)
                     documentVersionDto.Published = true; // now published
                     contentVersionDto.Current = false; // no more current
                 }
+
+                // Ensure existing version retains current preventCleanup flag (both saving and publishing).
+                contentVersionDto.PreventCleanup = version.PreventCleanup; 
+
                 Database.Update(contentVersionDto);
                 Database.Update(documentVersionDto);
 
@@ -641,6 +645,7 @@ protected override void PersistUpdatedItem(IContent entity)
                     contentVersionDto.Id = 0; // want a new id
                     contentVersionDto.Current = true; // current version
                     contentVersionDto.Text = entity.Name;
+                    contentVersionDto.PreventCleanup = false; // new draft version disregards prevent cleanup flag
                     Database.Insert(contentVersionDto);
                     entity.VersionId = documentVersionDto.Id = contentVersionDto.Id; // get the new id
 
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentVersionRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentVersionRepository.cs
index 5040ee5d7a70..21bd883c68c4 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentVersionRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentVersionRepository.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using NPoco;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Persistence.Repositories;
@@ -14,10 +15,8 @@ internal class DocumentVersionRepository : IDocumentVersionRepository
     {
         private readonly IScopeAccessor _scopeAccessor;
 
-        public DocumentVersionRepository(IScopeAccessor scopeAccessor)
-        {
+        public DocumentVersionRepository(IScopeAccessor scopeAccessor) =>
             _scopeAccessor = scopeAccessor ?? throw new ArgumentNullException(nameof(scopeAccessor));
-        }
 
         /// <inheritdoc />
         /// <remarks>
@@ -25,14 +24,19 @@ public DocumentVersionRepository(IScopeAccessor scopeAccessor)
         /// Never includes current published version.<br/>
         /// Never includes versions marked as "preventCleanup".<br/>
         /// </remarks>
-        public IReadOnlyCollection<HistoricContentVersionMeta> GetDocumentVersionsEligibleForCleanup()
+        public IReadOnlyCollection<ContentVersionMeta> GetDocumentVersionsEligibleForCleanup()
         {
-            var query = _scopeAccessor.AmbientScope.SqlContext.Sql();
+            Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql();
 
             query.Select(@"umbracoDocument.nodeId as contentId,
                            umbracoContent.contentTypeId as contentTypeId,
                            umbracoContentVersion.id as versionId,
-                           umbracoContentVersion.versionDate as versionDate")
+                           umbracoContentVersion.userId as userId,
+                           umbracoContentVersion.versionDate as versionDate,
+                           umbracoDocumentVersion.published as currentPublishedVersion,
+                           umbracoContentVersion.[current] as currentDraftVersion,
+                           umbracoContentVersion.preventCleanup as preventCleanup,
+                           umbracoUser.userName as username")
                 .From<DocumentDto>()
                 .InnerJoin<ContentDto>()
                     .On<DocumentDto, ContentDto>(left => left.NodeId, right => right.NodeId)
@@ -40,17 +44,19 @@ public IReadOnlyCollection<HistoricContentVersionMeta> GetDocumentVersionsEligib
                     .On<ContentDto, ContentVersionDto>(left => left.NodeId, right => right.NodeId)
                 .InnerJoin<DocumentVersionDto>()
                     .On<ContentVersionDto, DocumentVersionDto>(left => left.Id, right => right.Id)
+                .LeftJoin<UserDto>()
+                    .On<UserDto, ContentVersionDto>(left => left.Id, right => right.UserId)
                 .Where<ContentVersionDto>(x => !x.Current) // Never delete current draft version
                 .Where<ContentVersionDto>(x => !x.PreventCleanup) // Never delete "pinned" versions
                 .Where<DocumentVersionDto>(x => !x.Published); // Never delete published version
 
-            return _scopeAccessor.AmbientScope.Database.Fetch<HistoricContentVersionMeta>(query);
+            return _scopeAccessor.AmbientScope.Database.Fetch<ContentVersionMeta>(query);
         }
 
         /// <inheritdoc />
         public IReadOnlyCollection<ContentVersionCleanupPolicySettings> GetCleanupPolicies()
         {
-            var query = _scopeAccessor.AmbientScope.SqlContext.Sql();
+            Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql();
 
             query.Select<ContentVersionCleanupPolicyDto>()
                 .From<ContentVersionCleanupPolicyDto>();
@@ -58,21 +64,63 @@ public IReadOnlyCollection<ContentVersionCleanupPolicySettings> GetCleanupPolici
             return _scopeAccessor.AmbientScope.Database.Fetch<ContentVersionCleanupPolicySettings>(query);
         }
 
+        /// <inheritdoc />
+        public IEnumerable<ContentVersionMeta> GetPagedItemsByContentId(int contentId, long pageIndex, int pageSize, out long totalRecords, int? languageId = null)
+        {
+            Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql();
+
+            query.Select(@"umbracoDocument.nodeId as contentId,
+                           umbracoContent.contentTypeId as contentTypeId,
+                           umbracoContentVersion.id as versionId,
+                           umbracoContentVersion.userId as userId,
+                           umbracoContentVersion.versionDate as versionDate,
+                           umbracoDocumentVersion.published as currentPublishedVersion,
+                           umbracoContentVersion.[current] as currentDraftVersion,
+                           umbracoContentVersion.preventCleanup as preventCleanup,
+                           umbracoUser.userName as username")
+                .From<DocumentDto>()
+                .InnerJoin<ContentDto>()
+                    .On<DocumentDto, ContentDto>(left => left.NodeId, right => right.NodeId)
+                .InnerJoin<ContentVersionDto>()
+                    .On<ContentDto, ContentVersionDto>(left => left.NodeId, right => right.NodeId)
+                .InnerJoin<DocumentVersionDto>()
+                    .On<ContentVersionDto, DocumentVersionDto>(left => left.Id, right => right.Id)
+                .LeftJoin<UserDto>()
+                    .On<UserDto, ContentVersionDto>(left => left.Id, right => right.UserId)
+                .LeftJoin<ContentVersionCultureVariationDto>()
+                    .On<ContentVersionCultureVariationDto, ContentVersionDto>(left => left.VersionId, right => right.Id)
+                .Where<ContentVersionDto>(x => x.NodeId == contentId);
+
+            // TODO: If there's not a better way to write this then we need a better way to write this.
+            query = languageId.HasValue
+                ? query.Where<ContentVersionCultureVariationDto>(x => x.LanguageId == languageId.Value)
+                : query.Where("umbracoContentVersionCultureVariation.languageId is null");
+
+            query = query.OrderByDescending<ContentVersionDto>(x => x.Id);
+
+            Page<ContentVersionMeta> page = _scopeAccessor.AmbientScope.Database.Page<ContentVersionMeta>(pageIndex + 1, pageSize, query);
+
+            totalRecords = page.TotalItems;
+
+            return page.Items;
+        }
+
         /// <inheritdoc />
         /// <remarks>
         /// Deletes in batches of <see cref="Constants.Sql.MaxParameterCount"/>
         /// </remarks>
         public void DeleteVersions(IEnumerable<int> versionIds)
         {
-            foreach (var group in versionIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+            foreach (IEnumerable<int> group in versionIds.InGroupsOf(Constants.Sql.MaxParameterCount))
             {
                 var groupedVersionIds = group.ToList();
 
-                // Note: We had discussed doing this in a single SQL Command.
-                // If you can work out how to make that work with SQL CE, let me know!
-                // Can use test PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExceptActive to try things out.
+                /* Note: We had discussed doing this in a single SQL Command.
+                *  If you can work out how to make that work with SQL CE, let me know!
+                *  Can use test PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExceptActive to try things out.
+                */
 
-                var query = _scopeAccessor.AmbientScope.SqlContext.Sql()
+                Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql()
                     .Delete<PropertyDataDto>()
                     .WhereIn<PropertyDataDto>(x => x.VersionId, groupedVersionIds);
                 _scopeAccessor.AmbientScope.Database.Execute(query);
@@ -93,5 +141,43 @@ public void DeleteVersions(IEnumerable<int> versionIds)
                 _scopeAccessor.AmbientScope.Database.Execute(query);
             }
         }
+
+        /// <inheritdoc />
+        public void SetPreventCleanup(int versionId, bool preventCleanup)
+        {
+            Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql()
+                .Update<ContentVersionDto>(x => x.Set(y => y.PreventCleanup, preventCleanup))
+                .Where<ContentVersionDto>(x => x.Id == versionId);
+
+            _scopeAccessor.AmbientScope.Database.Execute(query);
+        }
+
+        /// <inheritdoc />
+        public ContentVersionMeta Get(int versionId)
+        {
+            Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql();
+
+            query.Select(@"umbracoDocument.nodeId as contentId,
+                           umbracoContent.contentTypeId as contentTypeId,
+                           umbracoContentVersion.id as versionId,
+                           umbracoContentVersion.userId as userId,
+                           umbracoContentVersion.versionDate as versionDate,
+                           umbracoDocumentVersion.published as currentPublishedVersion,
+                           umbracoContentVersion.[current] as currentDraftVersion,
+                           umbracoContentVersion.preventCleanup as preventCleanup,
+                           umbracoUser.userName as username")
+                .From<DocumentDto>()
+                .InnerJoin<ContentDto>()
+                    .On<DocumentDto, ContentDto>(left => left.NodeId, right => right.NodeId)
+                .InnerJoin<ContentVersionDto>()
+                    .On<ContentDto, ContentVersionDto>(left => left.NodeId, right => right.NodeId)
+                .InnerJoin<DocumentVersionDto>()
+                    .On<ContentVersionDto, DocumentVersionDto>(left => left.Id, right => right.Id)
+                .LeftJoin<UserDto>()
+                    .On<UserDto, ContentVersionDto>(left => left.Id, right => right.UserId)
+                .Where<ContentVersionDto>(x => x.Id == versionId);
+
+            return _scopeAccessor.AmbientScope.Database.Single<ContentVersionMeta>(query);
+        }
     }
 }
diff --git a/src/Umbraco.Infrastructure/Services/Implement/ContentVersionService.cs b/src/Umbraco.Infrastructure/Services/Implement/ContentVersionService.cs
index 26cffee9018d..e409f3af4777 100644
--- a/src/Umbraco.Infrastructure/Services/Implement/ContentVersionService.cs
+++ b/src/Umbraco.Infrastructure/Services/Implement/ContentVersionService.cs
@@ -9,6 +9,7 @@
 using Umbraco.Cms.Core.Scoping;
 using Umbraco.Extensions;
 
+// ReSharper disable once CheckNamespace
 namespace Umbraco.Cms.Core.Services.Implement
 {
     internal class ContentVersionService : IContentVersionService
@@ -19,6 +20,7 @@ internal class ContentVersionService : IContentVersionService
         private readonly IScopeProvider _scopeProvider;
         private readonly IEventMessagesFactory _eventMessagesFactory;
         private readonly IAuditRepository _auditRepository;
+        private readonly ILanguageRepository _languageRepository;
 
         public ContentVersionService(
             ILogger<ContentVersionService> logger,
@@ -26,7 +28,8 @@ public ContentVersionService(
             IContentVersionCleanupPolicy contentVersionCleanupPolicy,
             IScopeProvider scopeProvider,
             IEventMessagesFactory eventMessagesFactory,
-            IAuditRepository auditRepository)
+            IAuditRepository auditRepository,
+            ILanguageRepository languageRepository)
         {
             _logger = logger;
             _documentVersionRepository = documentVersionRepository;
@@ -34,27 +37,20 @@ public ContentVersionService(
             _scopeProvider = scopeProvider;
             _eventMessagesFactory = eventMessagesFactory;
             _auditRepository = auditRepository;
+            _languageRepository = languageRepository;
         }
 
         /// <inheritdoc />
-        /// <remarks>
-        ///     In v9 this can live in another class as we publish the notifications via IEventAggregator.
-        ///     But for v8 must be here for access to the static events.
-        /// </remarks>
-        public IReadOnlyCollection<HistoricContentVersionMeta> PerformContentVersionCleanup(DateTime asAtDate)
+        public IReadOnlyCollection<ContentVersionMeta> PerformContentVersionCleanup(DateTime asAtDate)
         {
             // Media - ignored
             // Members - ignored
             return CleanupDocumentVersions(asAtDate);
         }
 
-
-        /// <remarks>
-        ///     v9 - move to another class
-        /// </remarks>
-        private IReadOnlyCollection<HistoricContentVersionMeta> CleanupDocumentVersions(DateTime asAtDate)
+        private IReadOnlyCollection<ContentVersionMeta> CleanupDocumentVersions(DateTime asAtDate)
         {
-            List<HistoricContentVersionMeta> versionsToDelete;
+            List<ContentVersionMeta> versionsToDelete;
 
             /* Why so many scopes?
              *
@@ -84,18 +80,18 @@ private IReadOnlyCollection<HistoricContentVersionMeta> CleanupDocumentVersions(
              */
             using (IScope scope = _scopeProvider.CreateScope(autoComplete: true))
             {
-                var allHistoricVersions = _documentVersionRepository.GetDocumentVersionsEligibleForCleanup();
+                IReadOnlyCollection<ContentVersionMeta> allHistoricVersions = _documentVersionRepository.GetDocumentVersionsEligibleForCleanup();
 
                 _logger.LogDebug("Discovered {count} candidate(s) for ContentVersion cleanup", allHistoricVersions.Count);
-                versionsToDelete = new List<HistoricContentVersionMeta>(allHistoricVersions.Count);
+                versionsToDelete = new List<ContentVersionMeta>(allHistoricVersions.Count);
 
-                var filteredContentVersions = _contentVersionCleanupPolicy.Apply(asAtDate, allHistoricVersions);
+                IEnumerable<ContentVersionMeta> filteredContentVersions = _contentVersionCleanupPolicy.Apply(asAtDate, allHistoricVersions);
 
-                foreach (var version in filteredContentVersions)
+                foreach (ContentVersionMeta version in filteredContentVersions)
                 {
-                    EventMessages evtMsgs = _eventMessagesFactory.Get();
+                    EventMessages messages = _eventMessagesFactory.Get();
 
-                    if (scope.Notifications.PublishCancelable(new ContentDeletingVersionsNotification(version.ContentId, evtMsgs, version.VersionId)))
+                    if (scope.Notifications.PublishCancelable(new ContentDeletingVersionsNotification(version.ContentId, messages, version.VersionId)))
                     {
                         _logger.LogDebug("Delete cancelled for ContentVersion [{versionId}]", version.VersionId);
                         continue;
@@ -107,13 +103,13 @@ private IReadOnlyCollection<HistoricContentVersionMeta> CleanupDocumentVersions(
 
             if (!versionsToDelete.Any())
             {
-                _logger.LogDebug("No remaining ContentVersions for cleanup", versionsToDelete.Count);
-                return Array.Empty<HistoricContentVersionMeta>();
+                _logger.LogDebug("No remaining ContentVersions for cleanup");
+                return Array.Empty<ContentVersionMeta>();
             }
 
             _logger.LogDebug("Removing {count} ContentVersion(s)", versionsToDelete.Count);
 
-            foreach (var group in versionsToDelete.InGroupsOf(Constants.Sql.MaxParameterCount))
+            foreach (IEnumerable<ContentVersionMeta> group in versionsToDelete.InGroupsOf(Constants.Sql.MaxParameterCount))
             {
                 using (IScope scope = _scopeProvider.CreateScope(autoComplete: true))
                 {
@@ -121,17 +117,16 @@ private IReadOnlyCollection<HistoricContentVersionMeta> CleanupDocumentVersions(
                     var groupEnumerated = group.ToList();
                     _documentVersionRepository.DeleteVersions(groupEnumerated.Select(x => x.VersionId));
 
-                    foreach (var version in groupEnumerated)
+                    foreach (ContentVersionMeta version in groupEnumerated)
                     {
-                        EventMessages evtMsgs = _eventMessagesFactory.Get();
+                        EventMessages messages = _eventMessagesFactory.Get();
 
-                        scope.Notifications.Publish(
-                            new ContentDeletedVersionsNotification(version.ContentId, evtMsgs, version.VersionId));
+                        scope.Notifications.Publish(new ContentDeletedVersionsNotification(version.ContentId, messages, version.VersionId));
                     }
                 }
             }
 
-            using (IScope scope = _scopeProvider.CreateScope(autoComplete: true))
+            using (_scopeProvider.CreateScope(autoComplete: true))
             {
                 Audit(AuditType.Delete, Constants.Security.SuperUserId, -1, $"Removed {versionsToDelete.Count} ContentVersion(s) according to cleanup policy");
             }
@@ -139,8 +134,58 @@ private IReadOnlyCollection<HistoricContentVersionMeta> CleanupDocumentVersions(
             return versionsToDelete;
         }
 
-        private void Audit(AuditType type, int userId, int objectId, string message = null, string parameters = null) =>
-            _auditRepository.Save(new AuditItem(objectId, type, userId, UmbracoObjectTypes.Document.GetName(), message,
-                parameters));
+        /// <inheritdoc />
+        public IEnumerable<ContentVersionMeta> GetPagedContentVersions(int contentId, long pageIndex, int pageSize, out long totalRecords, string culture = null)
+        {
+            if (pageIndex < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(pageIndex));
+            }
+
+            if (pageSize <= 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(pageSize));
+            }
+
+            using (IScope scope = _scopeProvider.CreateScope(autoComplete: true))
+            {
+                var languageId = _languageRepository.GetIdByIsoCode(culture, throwOnNotFound: true);
+                scope.ReadLock(Constants.Locks.ContentTree);
+                return _documentVersionRepository.GetPagedItemsByContentId(contentId, pageIndex, pageSize, out totalRecords, languageId);
+            }
+        }
+
+        /// <inheritdoc />
+        public void SetPreventCleanup(int versionId, bool preventCleanup, int userId = -1)
+        {
+            using (IScope scope = _scopeProvider.CreateScope(autoComplete: true))
+            {
+                scope.WriteLock(Constants.Locks.ContentTree);
+                _documentVersionRepository.SetPreventCleanup(versionId, preventCleanup);
+
+                ContentVersionMeta version = _documentVersionRepository.Get(versionId);
+
+                AuditType auditType = preventCleanup
+                    ? AuditType.ContentVersionPreventCleanup
+                    : AuditType.ContentVersionEnableCleanup;
+
+                var message = $"set preventCleanup = '{preventCleanup}' for version '{versionId}'";
+
+                Audit(auditType, userId, version.ContentId, message, $"{version.VersionDate}");
+            }
+        }
+
+        private void Audit(AuditType type, int userId, int objectId, string message = null, string parameters = null)
+        {
+            var entry = new AuditItem(
+                objectId,
+                type,
+                userId,
+                UmbracoObjectTypes.Document.GetName(),
+                message,
+                parameters);
+
+            _auditRepository.Save(entry);
+        }
     }
 }
diff --git a/src/Umbraco.Infrastructure/Services/Implement/DefaultContentVersionCleanupPolicy.cs b/src/Umbraco.Infrastructure/Services/Implement/DefaultContentVersionCleanupPolicy.cs
index 383554c34c68..30193396ee22 100644
--- a/src/Umbraco.Infrastructure/Services/Implement/DefaultContentVersionCleanupPolicy.cs
+++ b/src/Umbraco.Infrastructure/Services/Implement/DefaultContentVersionCleanupPolicy.cs
@@ -24,14 +24,14 @@ public DefaultContentVersionCleanupPolicy(IOptions<ContentSettings> contentSetti
             _documentVersionRepository = documentVersionRepository ?? throw new ArgumentNullException(nameof(documentVersionRepository));
         }
 
-        public IEnumerable<HistoricContentVersionMeta> Apply(DateTime asAtDate, IEnumerable<HistoricContentVersionMeta> items)
+        public IEnumerable<ContentVersionMeta> Apply(DateTime asAtDate, IEnumerable<ContentVersionMeta> items)
         {
             // Note: Not checking global enable flag, that's handled in the scheduled job.
             // If this method is called and policy is globally disabled someone has chosen to run in code.
 
             var globalPolicy = _contentSettings.Value.ContentVersionCleanupPolicy;
 
-            var theRest = new List<HistoricContentVersionMeta>();
+            var theRest = new List<ContentVersionMeta>();
 
             using(_scopeProvider.CreateScope(autoComplete: true))
             {
@@ -76,13 +76,16 @@ public IEnumerable<HistoricContentVersionMeta> Apply(DateTime asAtDate, IEnumera
 
                 foreach (var group in grouped)
                 {
-                    yield return group.OrderByDescending(x => x.VersionId).First();
+                    foreach (var version in group.OrderByDescending(x => x.VersionId).Skip(1))
+                    {
+                        yield return version;
+                    }
                 }
             }
         }
 
         private ContentVersionCleanupPolicySettings GetOverridePolicy(
-            HistoricContentVersionMeta version,
+            ContentVersionMeta version,
             IDictionary<int, ContentVersionCleanupPolicySettings> overrides)
         {
             _ = overrides.TryGetValue(version.ContentTypeId, out var value);
diff --git a/src/Umbraco.Web.BackOffice/Controllers/ContentController.cs b/src/Umbraco.Web.BackOffice/Controllers/ContentController.cs
index 70678545d9b2..a4210e0421e1 100644
--- a/src/Umbraco.Web.BackOffice/Controllers/ContentController.cs
+++ b/src/Umbraco.Web.BackOffice/Controllers/ContentController.cs
@@ -62,6 +62,7 @@ public class ContentController : ContentControllerBase
         private readonly ActionCollection _actionCollection;
         private readonly ISqlContext _sqlContext;
         private readonly IAuthorizationService _authorizationService;
+        private readonly IContentVersionService _contentVersionService;
         private readonly Lazy<IDictionary<string, ILanguage>> _allLangs;
         private readonly ILogger<ContentController> _logger;
         private readonly IScopeProvider _scopeProvider;
@@ -90,7 +91,8 @@ public ContentController(
             ISqlContext sqlContext,
             IJsonSerializer serializer,
             IScopeProvider scopeProvider,
-            IAuthorizationService authorizationService)
+            IAuthorizationService authorizationService,
+            IContentVersionService contentVersionService)
             : base(cultureDictionary, loggerFactory, shortStringHelper, eventMessages, localizedTextService, serializer)
         {
             _propertyEditors = propertyEditors;
@@ -109,6 +111,7 @@ public ContentController(
             _actionCollection = actionCollection;
             _sqlContext = sqlContext;
             _authorizationService = authorizationService;
+            _contentVersionService = contentVersionService;
             _logger = loggerFactory.CreateLogger<ContentController>();
             _scopeProvider = scopeProvider;
             _allLangs = new Lazy<IDictionary<string, ILanguage>>(() => _localizationService.GetAllLanguages().ToDictionary(x => x.IsoCode, x => x, StringComparer.InvariantCultureIgnoreCase));
@@ -2504,6 +2507,53 @@ public IActionResult PostNotificationOptions(int contentId, [FromQuery(Name = "n
             return NoContent();
         }
 
+        [HttpGet]
+        [JsonCamelCaseFormatter]
+        public IActionResult GetPagedContentVersions(
+            int contentId,
+            int pageNumber = 1,
+            int pageSize = 10,
+            string culture = null)
+        {
+            if (!string.IsNullOrEmpty(culture))
+            {
+                if (!_allLangs.Value.TryGetValue(culture, out _))
+                {
+                    return NotFound();
+                }
+            }
+
+            IEnumerable<ContentVersionMeta> results = _contentVersionService.GetPagedContentVersions(
+                contentId,
+                pageNumber - 1,
+                pageSize,
+                out var totalRecords,
+                culture);
+
+            var model = new PagedResult<ContentVersionMeta>(totalRecords, pageNumber, pageSize)
+            {
+                Items = results
+            };
+
+            return Ok(model);
+        }
+
+        [HttpPost]
+        [Authorize(Policy = AuthorizationPolicies.ContentPermissionAdministrationById)]
+        public IActionResult PostSetContentVersionPreventCleanup(int contentId, int versionId, bool preventCleanup)
+        {
+            IContent content = _contentService.GetVersion(versionId);
+
+            if (content == null || content.Id != contentId)
+            {
+                return NotFound();
+            }
+
+            _contentVersionService.SetPreventCleanup(versionId, preventCleanup, _backofficeSecurityAccessor.BackOfficeSecurity.GetUserId().ResultOr(0));
+
+            return NoContent();
+        }
+
         [HttpGet]
         public IEnumerable<RollbackVersion> GetRollbackVersions(int contentId, string culture = null)
         {
diff --git a/src/Umbraco.Web.UI.Client/src/common/resources/content.resource.js b/src/Umbraco.Web.UI.Client/src/common/resources/content.resource.js
index a836f8db3d7b..b6f45ead0e1e 100644
--- a/src/Umbraco.Web.UI.Client/src/common/resources/content.resource.js
+++ b/src/Umbraco.Web.UI.Client/src/common/resources/content.resource.js
@@ -1234,6 +1234,186 @@ function contentResource($q, $http, umbDataFormatter, umbRequestHelper) {
                 ),
                 "Failed to roll back content item with id " + contentId
             );
+        },
+
+        /**
+          * @ngdoc method
+          * @name umbraco.resources.contentResource#getPublicAccess
+          * @methodOf umbraco.resources.contentResource
+          *
+          * @description
+          * Returns the public access protection for a content item
+          *
+          * ##usage
+          * <pre>
+          * contentResource.getPublicAccess(contentId)
+          *    .then(function(publicAccess) {
+          *        // do your thing
+          *    });
+          * </pre>
+          *
+          * @param {Int} contentId The content Id
+          * @returns {Promise} resourcePromise object containing the public access protection
+          *
+          */
+        getPublicAccess: function (contentId) {
+            return umbRequestHelper.resourcePromise(
+                $http.get(
+                    umbRequestHelper.getApiUrl("contentApiBaseUrl", "GetPublicAccess", {
+                        contentId: contentId
+                    })
+                ),
+                "Failed to get public access for content item with id " + contentId
+            );
+        },
+
+        /**
+          * @ngdoc method
+          * @name umbraco.resources.contentResource#updatePublicAccess
+          * @methodOf umbraco.resources.contentResource
+          *
+          * @description
+          * Sets or updates the public access protection for a content item
+          *
+          * ##usage
+          * <pre>
+          * contentResource.updatePublicAccess(contentId, userName, password, roles, loginPageId, errorPageId)
+          *    .then(function() {
+          *        // do your thing
+          *    });
+          * </pre>
+          *
+          * @param {Int} contentId The content Id
+          * @param {Array} groups The names of the groups that should have access (if using group based protection)
+          * @param {Array} usernames The usernames of the members that should have access (if using member based protection)
+          * @param {Int} loginPageId The Id of the login page
+          * @param {Int} errorPageId The Id of the error page
+          * @returns {Promise} resourcePromise object containing the public access protection
+          *
+          */
+        updatePublicAccess: function (contentId, groups, usernames, loginPageId, errorPageId) {
+            var publicAccess = {
+                contentId: contentId,
+                loginPageId: loginPageId,
+                errorPageId: errorPageId
+            };
+            if (Utilities.isArray(groups) && groups.length) {
+                publicAccess.groups = groups;
+            }
+            else if (Utilities.isArray(usernames) && usernames.length) {
+                publicAccess.usernames = usernames;
+            }
+            else {
+                throw "must supply either userName/password or roles";
+            }
+            return umbRequestHelper.resourcePromise(
+                $http.post(
+                    umbRequestHelper.getApiUrl("contentApiBaseUrl", "PostPublicAccess", publicAccess)
+                ),
+                "Failed to update public access for content item with id " + contentId
+            );
+        },
+
+        /**
+          * @ngdoc method
+          * @name umbraco.resources.contentResource#removePublicAccess
+          * @methodOf umbraco.resources.contentResource
+          *
+          * @description
+          * Removes the public access protection for a content item
+          *
+          * ##usage
+          * <pre>
+          * contentResource.removePublicAccess(contentId)
+          *    .then(function() {
+          *        // do your thing
+          *    });
+          * </pre>
+          *
+          * @param {Int} contentId The content Id
+          * @returns {Promise} resourcePromise object that's resolved once the public access has been removed
+          *
+          */
+        removePublicAccess: function (contentId) {
+            return umbRequestHelper.resourcePromise(
+                $http.post(
+                    umbRequestHelper.getApiUrl("contentApiBaseUrl", "RemovePublicAccess", {
+                        contentId: contentId
+                    })
+                ),
+                "Failed to remove public access for content item with id " + contentId
+            );
+        },
+
+        /**
+          * @ngdoc method
+          * @name umbraco.resources.contentResource#getPagedContentVersions
+          * @methodOf umbraco.resources.contentResource
+          *
+          * @description
+          * Returns a paged array of previous version id's, given a node id, pageNumber, pageSize and a culture
+          *
+          * ##usage
+          * <pre>
+          * contentResource.getPagedContentVersions(id, pageNumber, pageSize, culture)
+          *    .then(function(versions) {
+          *        alert('its here!');
+          *    });
+          * </pre>
+          *
+          * @param {Int} id Id of node
+          * @param {Int} pageNumber page number
+          * @param {Int} pageSize page size
+          * @param {Int} culture if provided, the results will be for this specific culture/variant
+          * @returns {Promise} resourcePromise object containing the versions
+          *
+          */
+        getPagedContentVersions: function (contentId, pageNumber, pageSize, culture) {
+            return umbRequestHelper.resourcePromise(
+                $http.get(
+                    umbRequestHelper.getApiUrl("contentApiBaseUrl", "GetPagedContentVersions", {
+                        contentId: contentId,
+                        pageNumber: pageNumber,
+                        pageSize: pageSize,
+                        culture: culture
+                    })
+                ),
+                "Failed to get versions for content item with id " + contentId
+            );
+        },
+
+        /**
+          * @ngdoc method
+          * @name umbraco.resources.contentResource#contentVersionPreventCleanup
+          * @methodOf umbraco.resources.contentResource
+          *
+          * @description
+          * Enables or disabled clean up of a version
+          *
+          * ##usage
+          * <pre>
+          * contentResource.contentVersionPreventCleanup(contentId, versionId, preventCleanup)
+          *    .then(function() {
+          *        // do your thing
+          *    });
+          * </pre>
+          *
+          * @param {Int} contentId Id of node
+          * @param {Int} versionId Id of version
+          * @param {Int} preventCleanup Boolean to toggle clean up prevention
+          *
+          */
+        contentVersionPreventCleanup: function (contentId, versionId, preventCleanup) {
+            return umbRequestHelper.resourcePromise(
+                $http.post(
+                    umbRequestHelper.getApiUrl("contentApiBaseUrl", "PostSetContentVersionPreventCleanup", {
+                        contentId: contentId,
+                        versionId: versionId,
+                        preventCleanup: preventCleanup
+                    })
+                ),
+                "Failed to toggle prevent cleanup of version with id " + versionId
+            );
         }
     };
 }
diff --git a/src/Umbraco.Web.UI.Client/src/common/services/editor.service.js b/src/Umbraco.Web.UI.Client/src/common/services/editor.service.js
index 1f65bd7cea01..b146f471e0d8 100644
--- a/src/Umbraco.Web.UI.Client/src/common/services/editor.service.js
+++ b/src/Umbraco.Web.UI.Client/src/common/services/editor.service.js
@@ -527,7 +527,7 @@ When building a custom infinite editor view you can use the same components as a
          */
         function rollback(editor) {
             editor.view = "views/common/infiniteeditors/rollback/rollback.html";
-            if (!editor.size) editor.size = "medium";
+            if (!editor.size) editor.size = "";
             open(editor);
         }
 
diff --git a/src/Umbraco.Web.UI.Client/src/less/belle.less b/src/Umbraco.Web.UI.Client/src/less/belle.less
index 6f95608d7a8d..ba4df33aa0b3 100644
--- a/src/Umbraco.Web.UI.Client/src/less/belle.less
+++ b/src/Umbraco.Web.UI.Client/src/less/belle.less
@@ -203,6 +203,8 @@
 
 @import "components/umbemailmarketing.less";
 
+// Editors
+@import "../views/common/infiniteeditors/rollback/rollback.less";
 
 // Property Editors
 @import "../views/components/blockcard/umb-block-card-grid.less";
diff --git a/src/Umbraco.Web.UI.Client/src/less/components/buttons/umb-button.less b/src/Umbraco.Web.UI.Client/src/less/components/buttons/umb-button.less
index b6800aba65fc..88e172db0ced 100644
--- a/src/Umbraco.Web.UI.Client/src/less/components/buttons/umb-button.less
+++ b/src/Umbraco.Web.UI.Client/src/less/components/buttons/umb-button.less
@@ -91,6 +91,11 @@
    color: @white;
 }
 
+.umb-button__success.-black,
+.umb-button__error.-black {
+   color: @black;
+}
+
 .umb-button__overlay {
    position: absolute;
    width: 100%;
diff --git a/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.controller.js b/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.controller.js
index 4b0dfcb8b47a..7f1dbad69153 100644
--- a/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.controller.js
@@ -1,7 +1,7 @@
 (function () {
     "use strict";
 
-    function RollbackController($scope, contentResource, localizationService, assetsService, dateHelper, userService) {
+    function RollbackController($scope, contentResource, localizationService, assetsService, dateHelper, userService, notificationsService) {
 
         var vm = this;
 
@@ -10,6 +10,9 @@
         vm.changeVersion = changeVersion;
         vm.submit = submit;
         vm.close = close;
+        vm.pinVersion = pinVersion;
+        vm.goToPage = goToPage;
+        vm.paginationCount = { from: 0, to: 0, total: 0 };
 
         //////////
 
@@ -22,6 +25,11 @@
             vm.rollbackButtonDisabled = true;
             vm.labels = {};
 
+            vm.pageSize = 15;
+            vm.pageNumber = 1;
+            vm.totalPages = 1;
+            vm.totalItems = 0;
+
             // find the current version for invariant nodes
             if($scope.model.node.variants.length === 1) {
                 vm.currentVersion = $scope.model.node.variants[0];
@@ -61,27 +69,40 @@
 
         function changeLanguage(language) {
             vm.currentVersion = language;
+            vm.pageNumber = 1;
             getVersions();
         }
 
         function changeVersion(version) {
 
-            if(version && version.versionId) {
+            const canRollback = !version.currentDraftVersion && !version.currentPublishedVersion;
 
-                vm.loading = true;
+            if (canRollback === false) {
+                return;
+            }
 
+            if (vm.previousVersion && version && vm.previousVersion.versionId === version.versionId) {
+                vm.previousVersion = null;
+                vm.diff = null;
+                vm.rollbackButtonDisabled = true;
+                return;
+            }
+
+            if (version && version.versionId) {
+                vm.loadingDiff = true;
                 const culture = $scope.model.node.variants.length > 1 ? vm.currentVersion.language.culture : null;
 
                 contentResource.getRollbackVersion(version.versionId, culture)
                     .then(function(data) {
                         vm.previousVersion = data;
                         vm.previousVersion.versionId = version.versionId;
+                        vm.previousVersion.displayValue = version.displayValue + ' - ' + version.username;
                         createDiff(vm.currentVersion, vm.previousVersion);
 
-                        vm.loading = false;
+                        vm.loadingDiff = false;
                         vm.rollbackButtonDisabled = false;
                     }, function () {
-                        vm.loading = false;
+                        vm.loadingDiff = false;
                     });
 
             } else {
@@ -93,15 +114,26 @@
         function getVersions() {
 
             const nodeId = $scope.model.node.id;
-            const culture = $scope.model.node.variants.length > 1 ? vm.currentVersion.language.culture : null;
+            const culture = vm.currentVersion.language ? vm.currentVersion.language.culture : null;
 
-            return contentResource.getRollbackVersions(nodeId, culture)
+            return contentResource.getPagedContentVersions(nodeId, vm.pageNumber, vm.pageSize, culture)
                 .then(function (data) {
+                    vm.totalPages = data.totalPages;
+                    vm.totalItems = data.totalItems;
+
+                    const possibleTotalItems = vm.pageNumber * vm.pageSize;
+
+                    vm.paginationCount = {
+                        from: (vm.pageNumber * vm.pageSize - vm.pageSize) + 1,
+                        to: vm.totalItems < possibleTotalItems ? vm.totalItems : possibleTotalItems,
+                        total: vm.totalItems
+                    };
+
                     // get current backoffice user and format dates
                     userService.getCurrentUser().then(function (currentUser) {
-                        vm.previousVersions = data.map(version => {
+                        vm.previousVersions = data.items.map(version => {
                             var timestampFormatted = dateHelper.getLocalDate(version.versionDate, currentUser.locale, 'LLL');
-                            version.displayValue = timestampFormatted + ' - ' + version.versionAuthorName;
+                            version.displayValue = timestampFormatted;
                             return version;
                         });
                     });
@@ -200,6 +232,39 @@
             }
         }
 
+        function pinVersion (version, event) {
+            if (!version) {
+                return;
+            }
+
+            version.pinningState = 'busy';
+
+            const nodeId = $scope.model.node.id;
+            const versionId = version.versionId;
+            const preventCleanup = !version.preventCleanup;
+
+            contentResource.contentVersionPreventCleanup(nodeId, versionId, preventCleanup)
+                .then(() => {
+                    version.pinningState = 'success';
+                    version.preventCleanup = preventCleanup;
+                }, () => {
+                    version.pinningState = 'error';
+
+                    const localizationKey = preventCleanup ? 'speechBubbles_preventCleanupEnableError' : 'speechBubbles_preventCleanupDisableError';
+
+                    localizationService.localize(localizationKey).then(value => {
+                        notificationsService.error(value);
+                    });
+                });
+
+            event.stopPropagation();
+        }
+
+        function goToPage (pageNumber) {
+            vm.pageNumber = pageNumber;
+            getVersions();
+        }
+
         onInit();
 
     }
diff --git a/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.html b/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.html
index e48b5991f602..a5ac2ea6cb4c 100644
--- a/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.html
+++ b/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.html
@@ -1,4 +1,4 @@
-<div ng-controller="Umbraco.Editors.RollbackController as vm">
+<div class="editor-rollback" ng-controller="Umbraco.Editors.RollbackController as vm">
 
     <umb-editor-view>
 
@@ -16,75 +16,138 @@
                 ng-if="vm.loading">
             </umb-load-indicator>
 
-            <umb-box>
-                <umb-box-content>
-
-                    <div ng-if="model.node.variants.length > 1">
-                        <h5><localize key="general_language">Language</localize></h5>
-                        <select
-                            class="input-block-level"
-                            ng-model="vm.selectedLanguage"
-                            ng-options="variant as variant.displayName for variant in model.node.variants track by variant.language.culture"
-                            ng-change="vm.changeLanguage(vm.selectedLanguage)">
-                        </select>
-                    </div>
-
-                    <div>
-
-                        <h5><localize key="rollback_currentVersion">Current version</localize></h5>
-                        <p>{{vm.currentVersion.name}} (<localize key="rollback_created">Created</localize>: {{vm.currentVersion.createDate}})</p>
-
-                        <h5><localize key="rollback_rollbackTo">Rollback to</localize></h5>
-                        <select
-                            class="input-block-level"
-                            ng-model="vm.selectedVersion"
-                            ng-options="version.displayValue for version in vm.previousVersions track by version.versionId"
-                            ng-change="vm.changeVersion(vm.selectedVersion)">
-                            <option value="">{{vm.labels.choose}}...</option>
-                        </select>
-                    </div>
-
-                    <div ng-if="vm.diff && !vm.loading" class="diff" style="border-top: 1px solid #e9e9eb; margin-top: 30px;">
-
-                        <h5><localize key="rollback_changes">Changes</localize></h5>
-                        <small style="margin-bottom: 15px; display: block;">
-                            <localize key="rollback_diffHelp">
-                                This shows the differences between the current version and the selected version<br /><del>Red text</del> will be
-                                removed in the selected version, <ins>green text</ins> will be added
+            <div class="main-content">
+
+                <umb-box class="side-panel">
+                    <umb-box-header title-key="rollback_versions">
+                        <small>
+                            <localize 
+                                key="rollback_pagination"
+                                tokens="[vm.paginationCount.from, vm.paginationCount.to, vm.paginationCount.total]"
+                                watch-tokens="true">
                             </localize>
                         </small>
-
-                        <table class="table table-condensed table-bordered">
-                            <tbody>
-                                <tr>
-                                    <td class="bold">
-                                        <localize key="general_name">Name</localize>
-                                    </td>
-                                    <td>
-                                        <span ng-repeat="part in vm.diff.name track by $id(part)">
-                                            <ins ng-if="part.added">{{part.value}}</ins>
-                                            <del ng-if="part.removed">{{part.value}}</del>
-                                            <span ng-if="!part.added && !part.removed">{{part.value}}</span>
-                                        </span>
-                                    </td>
-                                </tr>
-                                <tr ng-repeat="property in vm.diff.properties track by property.alias">
-                                    <td class="bold">{{property.label}}</td>
-                                    <td ng-class="{'pre-line': property.isObject, 'word-wrap': !property.isObject}">
-                                        <span ng-repeat="part in property.diff track by $id(part)">
-                                            <ins ng-if="part.added">{{part.value}}</ins>
-                                            <del ng-if="part.removed">{{part.value}}</del>
-                                            <span ng-if="!part.added && !part.removed">{{part.value}}</span>
-                                        </span>
-                                    </td>
-                                </tr>
-                            </tbody>
-                        </table>
-
-                    </div>
-
-                </umb-box-content>
-            </umb-box>
+                    </umb-box-header>
+
+                    <umb-box-content>
+
+                        <div ng-if="model.node.variants.length > 1">
+                            <h5 class="mt0"><localize key="general_language">Language</localize></h5>
+                            <select
+                                class="culture-select input-block-level"
+                                ng-model="vm.selectedLanguage"
+                                ng-options="variant as variant.displayName for variant in model.node.variants track by variant.language.culture"
+                                ng-change="vm.changeLanguage(vm.selectedLanguage)">
+                            </select>
+                        </div>
+
+                        <div>
+                            <div class="current-version">
+                                <span class="bold"><localize key="rollback_currentVersion">Current version</localize>: </span>
+                                <span>{{vm.currentVersion.name}} (<localize key="rollback_created">Created</localize>: {{vm.currentVersion.createDate}})</span>
+                            </div>
+
+                            <div class="umb-table umb-table--condensed">
+
+                                <div class="umb-table-body">
+                                    <div class="umb-table-row umb-outline"
+                                        ng-repeat="version in vm.previousVersions track by version.versionId"
+                                        ng-class="{'-selectable cursor-pointer': !version.currentDraftVersion && !version.currentPublishedVersion,'-selected': version.versionId === vm.previousVersion.versionId }"
+                                        ng-click="vm.changeVersion(version)">
+                                        <div class="umb-table-cell dn"></div>
+                                        <div class="umb-table-cell black">
+                                            <div class="flex flex-column">
+                                                <div>{{ version.displayValue }}</div>
+                                                <div class="version-details">{{version.username}}</div>
+                                                <div class="version-details">
+                                                    <localize ng-if="version.currentPublishedVersion" key="rollback_currentPublishedVersion">Current version</localize>
+                                                    <localize ng-if="version.currentDraftVersion" key="rollback_currentDraftVersion">Current version</localize>
+                                                </div>
+                                            </div>
+                                        </div>
+                                        <div class="umb-table-cell umb-table-cell--auto-width">
+                                            <umb-button 
+                                                style="margin-left: auto;"
+                                                button-style="outline"
+                                                type="button"
+                                                size="xxs"
+                                                state="version.pinningState"
+                                                action="vm.pinVersion(version, $event)"
+                                                label="{{ version.preventCleanup ? 'Enable cleanup' : 'Prevent cleanup' }}">
+                                            </umb-button>
+                                        </div>
+                                    </div>
+                                </div>
+
+                            </div>
+                        </div>
+
+                        <umb-pagination
+                            ng-if="vm.totalPages > 0 && !vm.loading"
+                            page-number="vm.pageNumber"
+                            total-pages="vm.totalPages"
+                            on-change="vm.goToPage(pageNumber)">
+                        </umb-pagination>
+
+                    </umb-box-content>
+                </umb-box>
+
+                <umb-box class="compare-panel">
+
+                    <umb-box-header ng-if="vm.previousVersion" title="{{vm.previousVersion.displayValue}}"></umb-box-header>
+
+                    <umb-box-content>
+
+                        <umb-load-indicator ng-if="vm.loadingDiff"></umb-load-indicator>
+
+                        <umb-empty-state
+                            ng-if="!vm.diff"
+                            position="center">
+                            <localize key="rollback_headline"></localize>
+                        </umb-empty-state>
+
+                        <div ng-if="vm.diff && !vm.loadingDiff" class="diff">
+                            
+                            <small class="db" style="margin-bottom: 15px;">
+                                <localize key="rollback_diffHelp">
+                                    This shows the differences between the current version and the selected version<br /><del>Red text</del> will be
+                                    removed in the selected version, <ins>green text</ins> will be added
+                                </localize>
+                            </small>
+
+                            <table class="table table-condensed table-bordered">
+                                <tbody>
+                                    <tr>
+                                        <td class="bold">
+                                            <localize key="general_name">Name</localize>
+                                        </td>
+                                        <td>
+                                            <span ng-repeat="part in vm.diff.name track by $id(part)">
+                                                <ins ng-if="part.added">{{part.value}}</ins>
+                                                <del ng-if="part.removed">{{part.value}}</del>
+                                                <span ng-if="!part.added && !part.removed">{{part.value}}</span>
+                                            </span>
+                                        </td>
+                                    </tr>
+                                    <tr ng-repeat="property in vm.diff.properties track by property.alias">
+                                        <td class="bold">{{property.label}}</td>
+                                        <td ng-class="{'pre-line': property.isObject, 'word-wrap': !property.isObject}">
+                                            <span ng-repeat="part in property.diff track by $id(part)">
+                                                <ins ng-if="part.added">{{part.value}}</ins>
+                                                <del ng-if="part.removed">{{part.value}}</del>
+                                                <span ng-if="!part.added && !part.removed">{{part.value}}</span>
+                                            </span>
+                                        </td>
+                                    </tr>
+                                </tbody>
+                            </table>
+
+                        </div>
+
+                    </umb-box-content>
+                </umb-box>
+
+            </div>
         </umb-editor-container>
 
         <umb-editor-footer>
diff --git a/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.less b/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.less
new file mode 100644
index 000000000000..e7953a4feada
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/views/common/infiniteeditors/rollback/rollback.less
@@ -0,0 +1,32 @@
+.editor-rollback {
+
+  .main-content {
+    display: flex;
+    gap: 20px;
+  }
+
+  .side-panel {
+    flex: 0 0 33%;
+  }
+
+  .compare-panel {
+    flex: 1 1 auto;
+    position: relative;
+  }
+
+  .current-version {
+    background: @gray-10;
+    padding: 15px;
+    margin-bottom: 12px;
+  }
+
+  .culture-select {
+    margin-bottom: 12px;
+  }
+
+  .version-details {
+    color: @gray-5;
+    font-size: 13px;
+  }
+
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web.UI.Client/src/views/components/buttons/umb-button.html b/src/Umbraco.Web.UI.Client/src/views/components/buttons/umb-button.html
index 552d0ffdb578..365aad38171a 100644
--- a/src/Umbraco.Web.UI.Client/src/views/components/buttons/umb-button.html
+++ b/src/Umbraco.Web.UI.Client/src/views/components/buttons/umb-button.html
@@ -1,9 +1,9 @@
 <div class="umb-button" ng-class="{'ml0': vm.generalActions, 'umb-button--block': vm.blockElement}" data-element="{{ vm.alias ? 'button-' + vm.alias : '' }}">
 
     <div ng-if="vm.innerState">
-        <umb-icon icon="icon-check" class="umb-button__success" ng-class="{'-hidden': vm.innerState !== 'success', '-white': vm.isPrimaryButtonStyle}"></umb-icon>
-        <umb-icon icon="icon-delete" class="umb-button__error" ng-class="{'-hidden': vm.innerState !== 'error', '-white': vm.isPrimaryButtonStyle}"></umb-icon>
-        <div class="umb-button__progress" ng-class="{'-hidden': vm.innerState !== 'busy', '-white': vm.isPrimaryButtonStyle}"></div>
+        <umb-icon icon="icon-check" class="umb-button__success" ng-class="{'-hidden': vm.innerState !== 'success', '-white': vm.isPrimaryButtonStyle, '-black': vm.buttonStyle === 'outline'}"></umb-icon>
+        <umb-icon icon="icon-delete" class="umb-button__error" ng-class="{'-hidden': vm.innerState !== 'error', '-white': vm.isPrimaryButtonStyle, '-black': vm.buttonStyle === 'outline'}"></umb-icon>
+        <div class="umb-button__progress" ng-class="{'-hidden': vm.innerState !== 'busy', '-white': vm.isPrimaryButtonStyle, '-black': vm.buttonStyle === 'outline'}"></div>
         <div ng-if="vm.innerState !== 'init'" class="umb-button__overlay"></div>
     </div>
 
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/en.xml b/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
index 707bb5631558..6922fe803d7b 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
@@ -170,6 +170,8 @@
     <key alias="sendtopublishvariant">Content sent for publishing for languages: %0%</key>
     <key alias="sort">Sort child items performed by user</key>
     <key alias="custom">%0%</key>
+    <key alias="contentversionpreventcleanup">Cleanup disabled for version: %0%</key>
+    <key alias="contentversionenablecleanup">Cleanup enabled for version: %0%</key>
     <key alias="smallCopy">Copy</key>
     <key alias="smallPublish">Publish</key>
     <key alias="smallPublishVariant">Publish</key>
@@ -183,6 +185,8 @@
     <key alias="smallSendToPublishVariant">Send To Publish</key>
     <key alias="smallSort">Sort</key>
     <key alias="smallCustom">Custom</key>
+    <key alias="smallContentVersionPreventCleanup">Save</key>
+    <key alias="smallContentVersionEnableCleanup">Save</key>
     <key alias="historyIncludingVariants">History (all variants)</key>
   </area>
   <area alias="codefile">
@@ -1833,7 +1837,7 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="historyCleanupKeepAllVersionsNewerThanDays">Keep all versions newer than days</key>
     <key alias="historyCleanupKeepLatestVersionPerDayForDays">Keep latest version per day for days</key>
     <key alias="historyCleanupPreventCleanup">Prevent cleanup</key>
-    <key alias="historyCleanupGloballyDisabled">NOTE! The cleanup of historically content versions is disabled globally. These settings will not take effect before it is enabled.</key>
+    <key alias="historyCleanupGloballyDisabled">NOTE! The content version cleanup feature is disabled globally. These settings will not take effect until it is enabled.</key>
   </area>
   <area alias="languages">
     <key alias="addLanguage">Add language</key>
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml b/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
index dbe779223402..4000682ed914 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
@@ -171,6 +171,8 @@
     <key alias="sendtopublishvariant">Content sent for publishing for languages: %0%</key>
     <key alias="sort">Sort child items performed by user</key>
     <key alias="custom">%0%</key>
+    <key alias="contentversionpreventcleanup">Cleanup disabled for version: %0%</key>
+    <key alias="contentversionenablecleanup">Cleanup enabled for version: %0%</key>
     <key alias="smallCopy">Copy</key>
     <key alias="smallPublish">Publish</key>
     <key alias="smallPublishVariant">Publish</key>
@@ -185,6 +187,8 @@
     <key alias="smallSendToPublishVariant">Send To Publish</key>
     <key alias="smallSort">Sort</key>
     <key alias="smallCustom">Custom</key>
+    <key alias="smallContentVersionPreventCleanup">Save</key>
+    <key alias="smallContentVersionEnableCleanup">Save</key>
     <key alias="historyIncludingVariants">History (all variants)</key>
   </area>
   <area alias="codefile">
@@ -1460,6 +1464,10 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="rollbackTo">Rollback to</key>
     <key alias="selectVersion">Select version</key>
     <key alias="view">View</key>
+    <key alias="pagination"><![CDATA[Showing version %0% to %1% of %2% versions]]></key>
+    <key alias="versions">Versions</key>
+    <key alias="currentDraftVersion">Current draft version</key>
+    <key alias="currentPublishedVersion">Current published version</key>
   </area>
   <area alias="scripts">
     <key alias="editscript">Edit script file</key>
@@ -1615,6 +1623,8 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="publishWithMissingDomain">There is no domain configured for %0%, please contact an administrator, see
       log for more information
     </key>
+    <key alias="preventCleanupEnableError">An error occurred while enabling version cleanup for %0%</key>
+    <key alias="preventCleanupDisableError">An error occurred while disabling version cleanup for %0%</key>
   </area>
   <area alias="stylesheet">
     <key alias="addRule">Add style</key>
@@ -1891,7 +1901,7 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="historyCleanupKeepAllVersionsNewerThanDays">Keep all versions newer than days</key>
     <key alias="historyCleanupKeepLatestVersionPerDayForDays">Keep latest version per day for days</key>
     <key alias="historyCleanupPreventCleanup">Prevent cleanup</key>
-    <key alias="historyCleanupGloballyDisabled">NOTE! The cleanup of historically content versions is disabled globally. These settings will not take effect before it is enabled.</key>
+    <key alias="historyCleanupGloballyDisabled">NOTE! The content version cleanup feature is disabled globally. These settings will not take effect until it is enabled.</key>
   </area>
   <area alias="languages">
     <key alias="addLanguage">Add language</key>
diff --git a/tests/Umbraco.Tests.AcceptanceTest/cypress/integration/Content/content.ts b/tests/Umbraco.Tests.AcceptanceTest/cypress/integration/Content/content.ts
index bc24573b6ab1..2aa409c51c03 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/cypress/integration/Content/content.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/cypress/integration/Content/content.ts
@@ -343,13 +343,7 @@ context('Content', () => {
         // Rollback
         cy.get('.umb-box-header :button').click();
 
-        cy.get('.umb-box-content > div > .input-block-level')
-            .find('option[label*=' + new Date().getDate() + ']')
-            .then(elements => {
-                const option = elements[elements.length - 1].getAttribute('value');
-                cy.get('.umb-box-content > div > .input-block-level')
-                    .select(option);
-            });
+        cy.get('.-selectable.cursor-pointer:first').click();
 
         cy.get('.umb-editor-footer-content__right-side > [button-style="success"] > .umb-button > .btn-success').click();
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs
index 1649aa2fc6bd..ba5c176ee2f4 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using NUnit.Framework;
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Scoping;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Infrastructure.Persistence.Dtos;
 using Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement;
@@ -31,7 +32,6 @@ public void GetDocumentVersionsEligibleForCleanup_Always_ExcludesActiveVersions(
 
             var contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
             ContentTypeService.Save(contentType);
-            ContentTypeService.Save(contentType);
 
             var content = ContentBuilder.CreateSimpleContent(contentType);
 
@@ -130,5 +130,75 @@ public void DeleteVersions_Always_DeletesSpecifiedVersions()
                 });
             }
         }
+
+
+        [Test]
+        public void GetPagedItemsByContentId_WithInvariantCultureContent_ReturnsPaginatedResults()
+        {
+            Template template = TemplateBuilder.CreateTextPageTemplate();
+            FileService.SaveTemplate(template);
+
+            var contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
+            ContentTypeService.Save(contentType);
+
+            var content = ContentBuilder.CreateSimpleContent(contentType);
+
+            ContentService.SaveAndPublish(content); // Draft + Published
+            ContentService.SaveAndPublish(content); // New Draft
+
+            using (ScopeProvider.CreateScope())
+            {
+                var sut = new DocumentVersionRepository((IScopeAccessor)ScopeProvider);
+                var page1 = sut.GetPagedItemsByContentId(content.Id, 0, 2, out var page1Total);
+                var page2 = sut.GetPagedItemsByContentId(content.Id, 1, 2, out var page2Total);
+
+                Assert.Multiple(() =>
+                {
+                    Assert.AreEqual(2, page1.Count());
+                    Assert.AreEqual(3, page1Total);
+
+                    Assert.AreEqual(1, page2.Count());
+                    Assert.AreEqual(3, page2Total);
+                });
+            }
+        }
+
+        [Test]
+        public void GetPagedItemsByContentId_WithVariantCultureContent_ReturnsPaginatedResults()
+        {
+            Template template = TemplateBuilder.CreateTextPageTemplate();
+            FileService.SaveTemplate(template);
+
+            var contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
+            contentType.Variations = ContentVariation.Culture;
+            foreach (var propertyType in contentType.PropertyTypes)
+            {
+                propertyType.Variations = ContentVariation.Culture;
+            }
+            FileService.SaveTemplate(contentType.DefaultTemplate);
+            ContentTypeService.Save(contentType);
+
+            var content = ContentBuilder.CreateSimpleContent(contentType, "foo", culture:"en-US");
+            content.SetCultureName("foo", "en-US");
+
+            ContentService.SaveAndPublish(content, "en-US"); // Draft + Published
+            ContentService.SaveAndPublish(content, "en-US"); // New Draft
+
+            using (ScopeProvider.CreateScope())
+            {
+                var sut = new DocumentVersionRepository((IScopeAccessor)ScopeProvider);
+                var page1 = sut.GetPagedItemsByContentId(content.Id, 0, 2, out var page1Total, 1);
+                var page2 = sut.GetPagedItemsByContentId(content.Id, 1, 2, out var page2Total, 1);
+
+                Assert.Multiple(() =>
+                {
+                    Assert.AreEqual(2, page1.Count());
+                    Assert.AreEqual(3, page1Total);
+
+                    Assert.AreEqual(1, page2.Count());
+                    Assert.AreEqual(3, page2Total);
+                });
+            }
+        }
     }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
index 907c12424aa0..11ff6db9891c 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
@@ -24,7 +24,7 @@ public void PerformContentVersionCleanup_Always_RespectsDeleteRevisionsCancellat
             [Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
             [Frozen] Mock<IContentVersionCleanupPolicy> policy,
             [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            List<HistoricContentVersionMeta> someHistoricVersions,
+            List<ContentVersionMeta> someHistoricVersions,
             DateTime aDateTime,
             ContentVersionService sut)
         {
@@ -38,7 +38,7 @@ public void PerformContentVersionCleanup_Always_RespectsDeleteRevisionsCancellat
                 .Returns(someHistoricVersions);
 
             // # Act
-            IReadOnlyCollection<HistoricContentVersionMeta> report = sut.PerformContentVersionCleanup(aDateTime);
+            IReadOnlyCollection<ContentVersionMeta> report = sut.PerformContentVersionCleanup(aDateTime);
 
             Assert.Multiple(() =>
             {
@@ -53,7 +53,7 @@ public void PerformContentVersionCleanup_Always_FiresDeletedVersionsForEachDelet
             [Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
             [Frozen] Mock<IContentVersionCleanupPolicy> policy,
             [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            List<HistoricContentVersionMeta> someHistoricVersions,
+            List<ContentVersionMeta> someHistoricVersions,
             DateTime aDateTime,
             ContentVersionService sut)
         {
@@ -78,7 +78,7 @@ public void PerformContentVersionCleanup_Always_ReturnsReportOfDeletedItems(
             [Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
             [Frozen] Mock<IContentVersionCleanupPolicy> policy,
             [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            List<HistoricContentVersionMeta> someHistoricVersions,
+            List<ContentVersionMeta> someHistoricVersions,
             DateTime aDateTime,
             ContentVersionService sut)
         {
@@ -104,7 +104,7 @@ public void PerformContentVersionCleanup_Always_AdheresToCleanupPolicy(
             [Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
             [Frozen] Mock<IContentVersionCleanupPolicy> policy,
             [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            List<HistoricContentVersionMeta> someHistoricVersions,
+            List<ContentVersionMeta> someHistoricVersions,
             DateTime aDateTime,
             ContentVersionService sut)
         {
@@ -115,8 +115,8 @@ public void PerformContentVersionCleanup_Always_AdheresToCleanupPolicy(
                 .Setup(x => x.PublishCancelable(It.IsAny<ICancelableNotification>()))
                 .Returns(false);
 
-            policy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<HistoricContentVersionMeta>>()))
-                .Returns<DateTime, IEnumerable<HistoricContentVersionMeta>>((_, items) => items.Take(1));
+            policy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<ContentVersionMeta>>()))
+                .Returns<DateTime, IEnumerable<ContentVersionMeta>>((_, items) => items.Take(1));
 
             // # Act
             var report = sut.PerformContentVersionCleanup(aDateTime);
@@ -138,7 +138,7 @@ public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnReposi
             [Frozen] Mock<IScopedNotificationPublisher> eventAggregator,
             [Frozen] Mock<IContentVersionCleanupPolicy> policy,
             [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            List<HistoricContentVersionMeta> someHistoricVersions,
+            List<ContentVersionMeta> someHistoricVersions,
             DateTime aDateTime,
             ContentVersionService sut)
         {
@@ -151,8 +151,8 @@ public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnReposi
 
             var filteredSet = someHistoricVersions.Take(1);
 
-            policy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<HistoricContentVersionMeta>>()))
-                .Returns<DateTime, IEnumerable<HistoricContentVersionMeta>>((_, items) => filteredSet);
+            policy.Setup(x => x.Apply(It.IsAny<DateTime>(), It.IsAny<IEnumerable<ContentVersionMeta>>()))
+                .Returns<DateTime, IEnumerable<ContentVersionMeta>>((_, items) => filteredSet);
 
             // # Act
             var report = sut.PerformContentVersionCleanup(aDateTime);
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs
index db258c5fa150..801c27110d11 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs
@@ -25,10 +25,10 @@ public void Apply_AllOlderThanKeepSettings_AllVersionsReturned(
         {
             var versionId = 0;
 
-            var historicItems = new List<HistoricContentVersionMeta>
+            var historicItems = new List<ContentVersionMeta>
             {
-                new HistoricContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
-                new HistoricContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
             };
 
             contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
@@ -60,10 +60,10 @@ public void Apply_OverlappingKeepSettings_KeepAllVersionsNewerThanDaysTakesPrior
         {
             var versionId = 0;
 
-            var historicItems = new List<HistoricContentVersionMeta>
+            var historicItems = new List<ContentVersionMeta>
             {
-                new HistoricContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
-                new HistoricContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
             };
 
             contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
@@ -93,21 +93,22 @@ public void Apply_WithinInKeepLatestPerDay_ReturnsSinglePerContentPerDay(
             [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
             DefaultContentVersionCleanupPolicy sut)
         {
-            var historicItems = new List<HistoricContentVersionMeta>
+            var historicItems = new List<ContentVersionMeta>
             {
-                new HistoricContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
 
-                new HistoricContentVersionMeta(versionId: 4, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddDays(-1).AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 5, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddDays(-1).AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 6, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddDays(-1).AddHours(-1)),
+                new ContentVersionMeta(versionId: 4, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 5, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 6, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-1), false, false, false, null),
                 // another content
-                new HistoricContentVersionMeta(versionId: 7, contentId: 2, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 8, contentId: 2, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 9, contentId: 2, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 7, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 8, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 9, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
             };
 
+
             contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
             {
                 ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
@@ -126,12 +127,16 @@ public void Apply_WithinInKeepLatestPerDay_ReturnsSinglePerContentPerDay(
 
             var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
+            // Keep latest per day for 3 days per content type
+            // 2 content types, one of which has 2 days of entries, the other only a single day
             Assert.Multiple(() =>
             {
-                Assert.AreEqual(3, results.Count);
-                Assert.True(results.Exists(x => x.VersionId == 3));
-                Assert.True(results.Exists(x => x.VersionId == 6));
-                Assert.True(results.Exists(x => x.VersionId == 9));
+                Assert.AreEqual(6, results.Count);
+                Assert.AreEqual(4, results.Count(x => x.ContentTypeId == 1));
+                Assert.AreEqual(2, results.Count(x => x.ContentTypeId == 2));
+                Assert.False(results.Any(x => x.VersionId == 9)); // Most recent for content type 2
+                Assert.False(results.Any(x => x.VersionId == 3)); // Most recent for content type 1 today
+                Assert.False(results.Any(x => x.VersionId == 6)); // Most recent for content type 1 yesterday
             });
         }
 
@@ -141,15 +146,15 @@ public void Apply_HasOverridePolicy_RespectsPreventCleanup(
             [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
             DefaultContentVersionCleanupPolicy sut)
         {
-            var historicItems = new List<HistoricContentVersionMeta>
+            var historicItems = new List<ContentVersionMeta>
             {
-                new HistoricContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
                 // another content & type
-                new HistoricContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
             };
 
             contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
@@ -182,15 +187,15 @@ public void Apply_HasOverridePolicy_RespectsKeepAll(
             [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
             DefaultContentVersionCleanupPolicy sut)
         {
-            var historicItems = new List<HistoricContentVersionMeta>
+            var historicItems = new List<ContentVersionMeta>
             {
-                new HistoricContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
                 // another content & type
-                new HistoricContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
             };
 
             contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
@@ -223,15 +228,19 @@ public void Apply_HasOverridePolicy_RespectsKeepLatest(
             [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
             DefaultContentVersionCleanupPolicy sut)
         {
-            var historicItems = new List<HistoricContentVersionMeta>
+            var historicItems = new List<ContentVersionMeta>
             {
-                new HistoricContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+                // another content
+                new ContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
                 // another content & type
-                new HistoricContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-3)),
-                new HistoricContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-2)),
-                new HistoricContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, versionDate: DateTime.Today.AddHours(-1)),
+                new ContentVersionMeta(versionId: 7, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+                new ContentVersionMeta(versionId: 8, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+                new ContentVersionMeta(versionId: 9, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
             };
 
             contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
@@ -255,10 +264,15 @@ public void Apply_HasOverridePolicy_RespectsKeepLatest(
 
             var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
+            // By default no historic versions are kept
+            // Override policy for content type 2 keeps latest per day for 3 days, no versions retained for content type with id 1
+            // There were 3 entries for content type 2 all on the same day
+            // version id 9 is most recent for content type 2, and should be filtered, all the rest should be present.
             Assert.Multiple(() =>
             {
-                Assert.AreEqual(3, results.Count(x => x.ContentTypeId == 1));
-                Assert.AreEqual(6, results.Single(x => x.ContentTypeId == 2).VersionId);
+                Assert.AreEqual(8, results.Count);
+                Assert.AreEqual(2, results.Count(x => x.ContentTypeId == 2));
+                Assert.False(results.Any(x => x.VersionId == 9));
             });
         }
     }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Web.BackOffice/Controllers/ContentControllerTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Web.BackOffice/Controllers/ContentControllerTests.cs
index 42b9eb2ddc8d..2d703b8d0fab 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Web.BackOffice/Controllers/ContentControllerTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Web.BackOffice/Controllers/ContentControllerTests.cs
@@ -261,7 +261,8 @@ private ContentController CreateContentController(IDomainService domainService)
                 Mock.Of<ISqlContext>(),
                 Mock.Of<IJsonSerializer>(),
                 Mock.Of<IScopeProvider>(),
-                Mock.Of<IAuthorizationService>()
+                Mock.Of<IAuthorizationService>(),
+                Mock.Of<IContentVersionService>()
             );
 
             return controller;