diff --git a/src/GovUk.Education.ExploreEducationStatistics.Admin.Tests/Services/PublicationServiceTests.cs b/src/GovUk.Education.ExploreEducationStatistics.Admin.Tests/Services/PublicationServiceTests.cs
index 7c4419a476..58a17e3297 100644
--- a/src/GovUk.Education.ExploreEducationStatistics.Admin.Tests/Services/PublicationServiceTests.cs
+++ b/src/GovUk.Education.ExploreEducationStatistics.Admin.Tests/Services/PublicationServiceTests.cs
@@ -3124,29 +3124,17 @@ public async Task UpdateReleaseSeries_UpdatesLatestPublishedReleaseVersion()
                 var viewModels = result.AssertRight();
                 Assert.Equal(3, viewModels.Count);
 
-                Assert.False(viewModels[0].IsLegacyLink);
-                Assert.Equal(release2021.Title, viewModels[0].Description);
                 Assert.Equal(release2021.Id, viewModels[0].ReleaseId);
-                Assert.Equal(release2021.Slug, viewModels[0].ReleaseSlug);
                 Assert.True(viewModels[0].IsLatest);
                 Assert.True(viewModels[0].IsPublished);
-                Assert.Null(viewModels[0].LegacyLinkUrl);
 
-                Assert.False(viewModels[1].IsLegacyLink);
-                Assert.Equal(release2020.Title, viewModels[1].Description);
                 Assert.Equal(release2020.Id, viewModels[1].ReleaseId);
-                Assert.Equal(release2020.Slug, viewModels[1].ReleaseSlug);
                 Assert.False(viewModels[1].IsLatest);
                 Assert.True(viewModels[1].IsPublished);
-                Assert.Null(viewModels[1].LegacyLinkUrl);
 
-                Assert.False(viewModels[2].IsLegacyLink);
-                Assert.Equal(release2022.Title, viewModels[2].Description);
                 Assert.Equal(release2022.Id, viewModels[2].ReleaseId);
-                Assert.Equal(release2022.Slug, viewModels[2].ReleaseSlug);
                 Assert.False(viewModels[2].IsLatest);
                 Assert.True(viewModels[2].IsPublished);
-                Assert.Null(viewModels[2].LegacyLinkUrl);
             }
 
             await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
@@ -3168,6 +3156,108 @@ public async Task UpdateReleaseSeries_UpdatesLatestPublishedReleaseVersion()
             }
         }
 
+        [Fact]
+        public async Task UpdateReleaseSeries_UpdatesLatestPublishedReleaseVersion_SkipsUnpublishedReleases()
+        {
+            Publication publication = _dataFixture
+                .DefaultPublication()
+                .WithReleases([
+                    _dataFixture
+                        .DefaultRelease(publishedVersions: 1, year: 2020),
+                    _dataFixture
+                        .DefaultRelease(publishedVersions: 0, draftVersion: true, year: 2021),
+                    _dataFixture
+                        .DefaultRelease(publishedVersions: 2, draftVersion: true, year: 2022)
+                ])
+                .WithTheme(_dataFixture.DefaultTheme());
+
+            var release2020 = publication.Releases.Single(r => r.Year == 2020);
+            var release2021 = publication.Releases.Single(r => r.Year == 2021);
+            var release2022 = publication.Releases.Single(r => r.Year == 2022);
+
+            var expectedLatestPublishedReleaseVersionId = release2020.Versions[0].Id;
+
+            // Check the publication's latest published release version in the generated test data setup
+            Assert.Equal(release2022.Versions[1].Id, publication.LatestPublishedReleaseVersionId);
+
+            // Check the expected order of the release series items in the generated test data setup
+            Assert.Equal(3, publication.ReleaseSeries.Count);
+            Assert.Equal(release2022.Id, publication.ReleaseSeries[0].ReleaseId);
+            Assert.Equal(release2021.Id, publication.ReleaseSeries[1].ReleaseId);
+            Assert.Equal(release2020.Id, publication.ReleaseSeries[2].ReleaseId);
+
+            var contentDbContextId = Guid.NewGuid().ToString();
+            await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
+            {
+                contentDbContext.Publications.Add(publication);
+                await contentDbContext.SaveChangesAsync();
+            }
+
+            await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
+            {
+                var publicationCacheService = new Mock<IPublicationCacheService>(Strict);
+                publicationCacheService.Setup(mock =>
+                        mock.UpdatePublication(publication.Slug))
+                    .ReturnsAsync(new PublicationCacheViewModel());
+
+                var releaseCacheService = new Mock<IReleaseCacheService>(Strict);
+                releaseCacheService.Setup(mock => mock.UpdateRelease(
+                        expectedLatestPublishedReleaseVersionId,
+                        publication.Slug,
+                        null))
+                    .ReturnsAsync(new ReleaseCacheViewModel(expectedLatestPublishedReleaseVersionId));
+
+                var publicationService = BuildPublicationService(
+                    contentDbContext,
+                    publicationCacheService: publicationCacheService.Object,
+                    releaseCacheService: releaseCacheService.Object);
+
+                var result = await publicationService.UpdateReleaseSeries(
+                    publication.Id,
+                    updatedReleaseSeriesItems:
+                    [
+                        new ReleaseSeriesItemUpdateRequest { ReleaseId = release2021.Id }, // Unpublished
+                        new ReleaseSeriesItemUpdateRequest { ReleaseId = release2020.Id },
+                        new ReleaseSeriesItemUpdateRequest { ReleaseId = release2022.Id }
+                    ]);
+
+                VerifyAllMocks(publicationCacheService, releaseCacheService);
+
+                var viewModels = result.AssertRight();
+                Assert.Equal(3, viewModels.Count);
+
+                Assert.Equal(release2021.Id, viewModels[0].ReleaseId);
+                Assert.False(viewModels[0].IsLatest);
+                Assert.False(viewModels[0].IsPublished);
+
+                Assert.Equal(release2020.Id, viewModels[1].ReleaseId);
+                Assert.True(viewModels[1].IsLatest);
+                Assert.True(viewModels[1].IsPublished);
+
+                Assert.Equal(release2022.Id, viewModels[2].ReleaseId);
+                Assert.False(viewModels[2].IsLatest);
+                Assert.True(viewModels[2].IsPublished);
+            }
+
+            await using (var contentDbContext = InMemoryApplicationDbContext(contentDbContextId))
+            {
+                var actualPublication = await contentDbContext.Publications
+                    .SingleAsync(p => p.Id == publication.Id);
+
+                var actualReleaseSeries = actualPublication.ReleaseSeries;
+                Assert.Equal(3, actualReleaseSeries.Count);
+
+                Assert.Equal(release2021.Id, actualReleaseSeries[0].ReleaseId);
+                Assert.Equal(release2020.Id, actualReleaseSeries[1].ReleaseId);
+                Assert.Equal(release2022.Id, actualReleaseSeries[2].ReleaseId);
+
+                // The latest published version of 2020 should now be the publication's latest published release
+                // version since it was positioned as the next release after 2021 which is unpublished
+                Assert.Equal(expectedLatestPublishedReleaseVersionId,
+                    actualPublication.LatestPublishedReleaseVersionId);
+            }
+        }
+
         [Fact]
         public async Task UpdateReleaseSeries_SetEmpty()
         {