diff --git a/approot/messages.xml b/approot/messages.xml
index 2cfb7606..c42f4514 100644
--- a/approot/messages.xml
+++ b/approot/messages.xml
@@ -110,6 +110,7 @@
 <message id="Lms.Admin.ScannerController.status-scheduled">Scheduled on {1}</message>
 <message id="Lms.Admin.ScannerController.status-in-progress">Scanning: step {1}/{2}</message>
 <message id="Lms.Admin.ScannerController.step-associating-artist-images">Associating artist images: {1}%...</message>
+<message id="Lms.Admin.ScannerController.step-associating-release-images">Associating release images: {1}%...</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-duplicate-files">Checking for duplicate files... {1} files</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-removed-files">Checking for removed files... {1}%</message>
 <message id="Lms.Admin.ScannerController.step-compact">Compacting database...</message>
diff --git a/approot/messages_fr.xml b/approot/messages_fr.xml
index 1f216c86..d160d292 100644
--- a/approot/messages_fr.xml
+++ b/approot/messages_fr.xml
@@ -110,6 +110,7 @@
 <message id="Lms.Admin.ScannerController.status-scheduled">Planifié le {1}</message>
 <message id="Lms.Admin.ScannerController.status-in-progress">En cours de scan : étape {1}/{2}</message>
 <message id="Lms.Admin.ScannerController.step-associating-artist-images">Association des images des artistes: {1}%...</message>
+<message id="Lms.Admin.ScannerController.step-associating-release-images">Association des images des albums: {1}%...</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-duplicate-files">Vérification des fichiers dupliqués... {1} fichiers</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-removed-files">Vérification des fichiers supprimés... {1}%</message>
 <message id="Lms.Admin.ScannerController.step-compact">Compactage de la base de données...</message>
diff --git a/approot/messages_it.xml b/approot/messages_it.xml
index a1daeb59..30127191 100644
--- a/approot/messages_it.xml
+++ b/approot/messages_it.xml
@@ -110,6 +110,7 @@
 <message id="Lms.Admin.ScannerController.status-scheduled">Pianificato il {1}</message>
 <message id="Lms.Admin.ScannerController.status-in-progress">Scansione: passo {1}/{2}</message>
 <message id="Lms.Admin.ScannerController.step-associating-artist-images">Associando immagini degli artisti: {1}%...</message>
+<message id="Lms.Admin.ScannerController.step-associating-release-images">Associando immagini degli album: {1}%...</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-duplicate-files">Controllo duplicati... {1} files</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-removed-files">Controllo file... {1}%</message>
 <message id="Lms.Admin.ScannerController.step-compact">Compattazione del database...</message>
diff --git a/approot/messages_pl.xml b/approot/messages_pl.xml
index a28bcb89..90c1c269 100644
--- a/approot/messages_pl.xml
+++ b/approot/messages_pl.xml
@@ -119,6 +119,7 @@
 <message id="Lms.Admin.ScannerController.status-scheduled">Zaplanowano na {1}</message>
 <message id="Lms.Admin.ScannerController.status-in-progress">Skanowanie: krok {1}/{2}</message>
 <message id="Lms.Admin.ScannerController.step-associating-artist-images">Kojarzenie obrazów artystów: {1}%...</message>
+<message id="Lms.Admin.ScannerController.step-associating-release-images">Kojarzenie obrazów albumów: {1}%...</message>
 <message id="Lms.Admin.ScannerController.step-checking-for-duplicate-files">
 	<plural case="0">Sprawdzanie duplikatów... {1} plik</plural>
 	<plural case="1">Sprawdzanie duplikatów... {1} pliki</plural>
diff --git a/approot/messages_zh.xml b/approot/messages_zh.xml
index 97f1b500..62206fe4 100644
--- a/approot/messages_zh.xml
+++ b/approot/messages_zh.xml
@@ -114,6 +114,7 @@
 
 
 
+
 <message id="Lms.Admin.ScannerController.step-discovering-files">检索文件中: {1} 文件</message>
 <message id="Lms.Admin.ScannerController.step-fetching-track-features">从 AcousticBrainz 获取音轨特征: {1}/{2} 音轨 ({3}%)...</message>
 
diff --git a/conf/lms.conf b/conf/lms.conf
index 4fcca840..82b565ce 100644
--- a/conf/lms.conf
+++ b/conf/lms.conf
@@ -74,9 +74,6 @@ api-open-subsonic-disabled-clients = ("DSub");
 # Turn on this option to allow the demo account creation/use
 demo = false;
 
-# Max external cover file size in MBytes
-cover-max-file-size = 10;
-
 # Max cover cache size in MBytes
 cover-max-cache-size = 30;
 
@@ -84,7 +81,7 @@ cover-max-cache-size = 30;
 cover-jpeg-quality = 75;
 
 # Preferred file names for covers (order is important)
-cover-preferred-file-names = ("cover", "front");
+cover-preferred-file-names = ("cover", "front", "folder", "default");
 
 # File names for artist images (order is important)
 # Note: files whose name is the artist's MBID are always searched before the names in this list. You can place the MBID files anywhere in your libraries.
diff --git a/src/libs/database/impl/Artist.cpp b/src/libs/database/impl/Artist.cpp
index 64d1a03c..cd49ff94 100644
--- a/src/libs/database/impl/Artist.cpp
+++ b/src/libs/database/impl/Artist.cpp
@@ -379,5 +379,4 @@ namespace lms::db
     {
         _image = getDboPtr(image);
     }
-
 } // namespace lms::db
diff --git a/src/libs/database/impl/Image.cpp b/src/libs/database/impl/Image.cpp
index 62db5af7..e2a0d02b 100644
--- a/src/libs/database/impl/Image.cpp
+++ b/src/libs/database/impl/Image.cpp
@@ -23,6 +23,7 @@
 
 #include "database/Artist.hpp"
 #include "database/Directory.hpp"
+#include "database/Release.hpp"
 #include "database/Session.hpp"
 
 #include "IdTypeTraits.hpp"
@@ -40,7 +41,7 @@ namespace lms::db
             if (params.directory.isValid())
                 query.where("i.directory_id = ?").bind(params.directory);
             if (!params.fileStem.empty())
-                query.where("i.stem = ?").bind(params.fileStem);
+                query.where("i.stem = ? COLLATE NOCASE").bind(params.fileStem);
 
             return query;
         }
diff --git a/src/libs/database/impl/Migration.cpp b/src/libs/database/impl/Migration.cpp
index b75f5c4b..5d869de5 100644
--- a/src/libs/database/impl/Migration.cpp
+++ b/src/libs/database/impl/Migration.cpp
@@ -35,7 +35,7 @@ namespace lms::db
 {
     namespace
     {
-        static constexpr Version LMS_DATABASE_VERSION{ 67 };
+        static constexpr Version LMS_DATABASE_VERSION{ 68 };
     }
 
     VersionInfo::VersionInfo()
@@ -761,6 +761,54 @@ SELECT
         session.getDboSession()->execute("ALTER TABLE user DROP COLUMN cur_playing_track_pos");
     }
 
+    void migrateFromV67(Session& session)
+    {
+        // Add a ref to release in image
+        session.getDboSession()->execute(R"(CREATE TABLE "image_backup" (
+  "id" integer primary key autoincrement,
+  "version" integer not null,
+  "absolute_file_path" text not null,
+  "stem" text not null,
+  "file_last_write" text,
+  "file_size" integer not null,
+  "width" integer not null,
+  "height" integer not null,
+  "artist_id" bigint,
+  "release_id" bigint,
+  "directory_id" bigint,
+  constraint "fk_image_artist" foreign key ("artist_id") references "artist" ("id") on delete cascade deferrable initially deferred,
+  constraint "fk_image_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred,
+  constraint "fk_image_directory" foreign key ("directory_id") references "directory" ("id") on delete cascade deferrable initially deferred
+))");
+
+        // Migrate data, with the new release_id field set to null
+        session.getDboSession()->execute(R"(INSERT INTO image_backup 
+SELECT
+ id,
+ version,
+ absolute_file_path,
+ stem,
+ file_last_write,
+ file_size,
+ width,
+ height,
+ artist_id,
+ NULL,
+ directory_id
+ FROM image
+ )");
+        session.getDboSession()->execute("DROP TABLE image");
+        session.getDboSession()->execute("ALTER TABLE image_backup RENAME TO image");
+
+        // Changed some indexes for the image table -> remove all the previoulsy created index, the createIndexesIfNeeded will recreate them all
+        std::vector<std::string> indexeNames{ utils::fetchQueryResults(session.getDboSession()->query<std::string>(R"(SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE '%_idx')")) };
+        for (const auto& indexName : indexeNames)
+            session.getDboSession()->execute("DROP INDEX " + indexName);
+
+        // Just increment the scan version of the settings to make the next scheduled scan rescan everything
+        session.getDboSession()->execute("UPDATE scan_settings SET scan_version = scan_version + 1");
+    }
+
     bool doDbMigration(Session& session)
     {
         static const std::string outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" };
@@ -804,6 +852,7 @@ SELECT
             { 64, migrateFromV64 },
             { 65, migrateFromV65 },
             { 66, migrateFromV66 },
+            { 67, migrateFromV67 },
         };
 
         bool migrationPerformed{};
diff --git a/src/libs/database/impl/Release.cpp b/src/libs/database/impl/Release.cpp
index 16f723de..687a4353 100644
--- a/src/libs/database/impl/Release.cpp
+++ b/src/libs/database/impl/Release.cpp
@@ -24,6 +24,8 @@
 #include "core/ILogger.hpp"
 #include "database/Artist.hpp"
 #include "database/Cluster.hpp"
+#include "database/Directory.hpp"
+#include "database/Image.hpp"
 #include "database/Session.hpp"
 #include "database/Track.hpp"
 #include "database/User.hpp"
@@ -540,6 +542,11 @@ namespace lms::db
         return utils::fetchQueryResults<Release::pointer>(query);
     }
 
+    ObjectPtr<Image> Release::getImage() const
+    {
+        return ObjectPtr<Image>{ _image.lock() };
+    }
+
     void Release::clearLabels()
     {
         _labels.clear();
@@ -560,6 +567,11 @@ namespace lms::db
         _releaseTypes.insert(getDboPtr(releaseType));
     }
 
+    void Release::setImage(ObjectPtr<Image> image)
+    {
+        _image = getDboPtr(image);
+    }
+
     bool Release::hasVariousArtists() const
     {
         // TODO optimize
@@ -665,5 +677,4 @@ namespace lms::db
 
         return res;
     }
-
 } // namespace lms::db
diff --git a/src/libs/database/impl/Session.cpp b/src/libs/database/impl/Session.cpp
index 14106053..c3380bcb 100644
--- a/src/libs/database/impl/Session.cpp
+++ b/src/libs/database/impl/Session.cpp
@@ -196,10 +196,11 @@ namespace lms::db
         _session.execute("CREATE INDEX IF NOT EXISTS directory_media_library_idx ON directory(media_library_id)");
 
         _session.execute("CREATE INDEX IF NOT EXISTS image_artist_idx ON image(artist_id)");
-        _session.execute("CREATE INDEX IF NOT EXISTS image_directory_idx ON image(directory_id)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_directory_stem_idx ON image(directory_id, stem COLLATE NOCASE)");
         _session.execute("CREATE INDEX IF NOT EXISTS image_id_idx ON image(id)");
         _session.execute("CREATE INDEX IF NOT EXISTS image_path_idx ON image(absolute_file_path)");
-        _session.execute("CREATE INDEX IF NOT EXISTS image_stem_idx ON image(stem)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_release_idx ON image(release_id)");
+        _session.execute("CREATE INDEX IF NOT EXISTS image_stem_idx ON image(stem COLLATE NOCASE)");
 
         _session.execute("CREATE INDEX IF NOT EXISTS label_name_idx ON label(name)");
 
diff --git a/src/libs/database/impl/Track.cpp b/src/libs/database/impl/Track.cpp
index cefcb539..c60e946d 100644
--- a/src/libs/database/impl/Track.cpp
+++ b/src/libs/database/impl/Track.cpp
@@ -157,6 +157,9 @@ namespace lms::db
             if (params.directory.isValid())
                 query.where("t.directory_id = ?").bind(params.directory);
 
+            if (params.hasEmbeddedImage.has_value())
+                query.where("t.has_cover = ?").bind(params.hasEmbeddedImage.value());
+
             switch (params.sortMethod)
             {
             case TrackSortMethod::None:
diff --git a/src/libs/database/include/database/Image.hpp b/src/libs/database/include/database/Image.hpp
index d2081835..6985e6ab 100644
--- a/src/libs/database/include/database/Image.hpp
+++ b/src/libs/database/include/database/Image.hpp
@@ -25,7 +25,6 @@
 #include <Wt/Dbo/Dbo.h>
 #include <Wt/WDateTime.h>
 
-#include "database/ArtistId.hpp"
 #include "database/DirectoryId.hpp"
 #include "database/ImageId.hpp"
 #include "database/Object.hpp"
@@ -35,6 +34,7 @@ namespace lms::db
 {
     class Artist;
     class Directory;
+    class Release;
     class Session;
 
     class Image final : public Object<Image, ImageId>
@@ -87,7 +87,16 @@ namespace lms::db
         void setFileSize(std::size_t fileSize) { _fileSize = fileSize; }
         void setWidth(std::size_t width) { _width = width; }
         void setHeight(std::size_t height) { _height = height; }
-        void setArtist(const ObjectPtr<Artist>& artist) { _artist = getDboPtr(artist); }
+        void setArtist(const ObjectPtr<Artist>& artist)
+        {
+            _artist = getDboPtr(artist);
+            _release = nullptr;
+        }
+        void setRelease(const ObjectPtr<Release>& release)
+        {
+            _release = getDboPtr(release);
+            _artist = nullptr;
+        }
         void setDirectory(const ObjectPtr<Directory>& directory) { _directory = getDboPtr(directory); }
 
         template<class Action>
@@ -102,6 +111,7 @@ namespace lms::db
             Wt::Dbo::field(a, _height, "height");
 
             Wt::Dbo::belongsTo(a, _artist, "artist", Wt::Dbo::OnDeleteCascade);
+            Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
             Wt::Dbo::belongsTo(a, _directory, "directory", Wt::Dbo::OnDeleteCascade);
         }
 
@@ -118,6 +128,7 @@ namespace lms::db
         int _height{};
 
         Wt::Dbo::ptr<Artist> _artist;
+        Wt::Dbo::ptr<Release> _release;
         Wt::Dbo::ptr<Directory> _directory;
     };
 } // namespace lms::db
diff --git a/src/libs/database/include/database/Release.hpp b/src/libs/database/include/database/Release.hpp
index 45db9fbe..11a22069 100644
--- a/src/libs/database/include/database/Release.hpp
+++ b/src/libs/database/include/database/Release.hpp
@@ -47,6 +47,7 @@ namespace lms::db
     class Artist;
     class Cluster;
     class ClusterType;
+    class Image;
     class Release;
     class Session;
     class Track;
@@ -245,6 +246,7 @@ namespace lms::db
         std::vector<std::string> getLabelNames() const;
         std::vector<std::string> getReleaseTypeNames() const;
         void visitLabels(const std::function<void(const Label::pointer& label)>& _func) const;
+        ObjectPtr<Image> getImage() const;
 
         // Setters
         void setName(std::string_view name) { _name = name; }
@@ -258,6 +260,7 @@ namespace lms::db
         void clearReleaseTypes();
         void addLabel(ObjectPtr<Label> releaseType);
         void addReleaseType(ObjectPtr<ReleaseType> releaseType);
+        void setImage(ObjectPtr<Image> image);
 
         // Get the artists of this release
         std::vector<ObjectPtr<Artist>> getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const;
@@ -278,6 +281,7 @@ namespace lms::db
             Wt::Dbo::field(a, _isCompilation, "is_compilation");
             Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToOne, "release");
 
+            Wt::Dbo::hasOne(a, _image, "release");
             Wt::Dbo::hasMany(a, _labels, Wt::Dbo::ManyToMany, "release_label", "", Wt::Dbo::OnDeleteCascade);
             Wt::Dbo::hasMany(a, _releaseTypes, Wt::Dbo::ManyToMany, "release_release_type", "", Wt::Dbo::OnDeleteCascade);
         }
@@ -300,6 +304,7 @@ namespace lms::db
         std::string _artistDisplayName;
         bool _isCompilation{}; // See https://picard-docs.musicbrainz.org/en/appendices/tag_mapping.html#compilation-itunes-5
 
+        Wt::Dbo::weak_ptr<Image> _image;
         Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
         Wt::Dbo::collection<Wt::Dbo::ptr<Label>> _labels;
         Wt::Dbo::collection<Wt::Dbo::ptr<ReleaseType>> _releaseTypes;
diff --git a/src/libs/database/include/database/Track.hpp b/src/libs/database/include/database/Track.hpp
index 50060e64..8e9d3d9a 100644
--- a/src/libs/database/include/database/Track.hpp
+++ b/src/libs/database/include/database/Track.hpp
@@ -83,6 +83,7 @@ namespace lms::db
             std::optional<int> discNumber;                           // matching this disc number
             MediaLibraryId mediaLibrary;                             // If set, tracks in this library
             DirectoryId directory;                                   // if set, tracks in this directory
+            std::optional<bool> hasEmbeddedImage;                    // if set, tracks that have or not embedded images
 
             FindParameters& setClusters(std::span<const ClusterId> _clusters)
             {
@@ -172,6 +173,11 @@ namespace lms::db
                 directory = _directory;
                 return *this;
             }
+            FindParameters& setHasEmbeddedImage(std::optional<bool> _hasEmbeddedImage)
+            {
+                hasEmbeddedImage = _hasEmbeddedImage;
+                return *this;
+            }
         };
 
         struct PathResult
diff --git a/src/libs/services/cover/impl/CoverService.cpp b/src/libs/services/cover/impl/CoverService.cpp
index 7c621aed..b42bbcae 100644
--- a/src/libs/services/cover/impl/CoverService.cpp
+++ b/src/libs/services/cover/impl/CoverService.cpp
@@ -19,8 +19,6 @@
 
 #include "CoverService.hpp"
 
-#include <set>
-
 #include "av/IAudioFile.hpp"
 #include "core/IConfig.hpp"
 #include "core/ILogger.hpp"
@@ -41,52 +39,6 @@ namespace lms::cover
 {
     namespace
     {
-        struct TrackInfo
-        {
-            bool hasCover{};
-            bool isMultiDisc{};
-            std::filesystem::path trackPath;
-            std::optional<db::ReleaseId> releaseId;
-        };
-
-        std::optional<TrackInfo> getTrackInfo(db::Session& dbSession, db::TrackId trackId)
-        {
-            std::optional<TrackInfo> res;
-
-            auto transaction{ dbSession.createReadTransaction() };
-
-            const db::Track::pointer track{ db::Track::find(dbSession, trackId) };
-            if (!track)
-                return res;
-
-            res = TrackInfo{};
-
-            res->hasCover = track->hasCover();
-            res->trackPath = track->getAbsoluteFilePath();
-
-            if (const db::Release::pointer & release{ track->getRelease() })
-            {
-                res->releaseId = release->getId();
-                if (release->getTotalDisc() > 1)
-                    res->isMultiDisc = true;
-            }
-
-            return res;
-        }
-
-        std::vector<std::string> constructPreferredFileNames()
-        {
-            std::vector<std::string> res;
-
-            core::Service<core::IConfig>::get()->visitStrings("cover-preferred-file-names",
-                [&res](std::string_view fileName) {
-                    res.emplace_back(fileName);
-                },
-                { "cover", "front" });
-
-            return res;
-        }
-
         bool isFileSupported(const std::filesystem::path& file, const std::vector<std::filesystem::path>& extensions)
         {
             return (std::find(std::cbegin(extensions), std::cend(extensions), file.extension()) != std::cend(extensions));
@@ -104,15 +56,11 @@ namespace lms::cover
         const std::filesystem::path& defaultSvgCoverPath)
         : _db{ db }
         , _cache{ core::Service<core::IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000 }
-        , _maxFileSize{ core::Service<core::IConfig>::get()->getULong("cover-max-file-size", 10) * 1000 * 1000 }
-        , _preferredFileNames{ constructPreferredFileNames() }
     {
         setJpegQuality(core::Service<core::IConfig>::get()->getULong("cover-jpeg-quality", 75));
 
         LMS_LOG(COVER, INFO, "Default cover path = '" << defaultSvgCoverPath.string() << "'");
         LMS_LOG(COVER, INFO, "Max cache size = " << _cache.getMaxCacheSize());
-        LMS_LOG(COVER, INFO, "Max file size = " << _maxFileSize);
-        LMS_LOG(COVER, INFO, "Preferred file names: " << core::stringUtils::joinStrings(_preferredFileNames, ","));
 
         _defaultCover = image::readSvgFile(defaultSvgCoverPath); // may throw
     }
@@ -140,7 +88,7 @@ namespace lms::cover
         return image;
     }
 
-    std::unique_ptr<IEncodedImage> CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width) const
+    std::unique_ptr<IEncodedImage> CoverService::getFromImageFile(const std::filesystem::path& p, ImageSize width) const
     {
         std::unique_ptr<IEncodedImage> image;
 
@@ -163,66 +111,7 @@ namespace lms::cover
         return _defaultCover;
     }
 
-    std::unique_ptr<IEncodedImage> CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width, const std::vector<std::string>& preferredFileNames, bool allowPickRandom) const
-    {
-        const std::multimap<std::string, std::filesystem::path> coverPaths{ getCoverPaths(directory) };
-
-        auto tryLoadImageFromFilename = [&](std::string_view fileName) {
-            std::unique_ptr<IEncodedImage> image;
-
-            auto range{ coverPaths.equal_range(std::string{ fileName }) };
-            for (auto it{ range.first }; it != range.second; ++it)
-            {
-                image = getFromCoverFile(it->second, width);
-                if (image)
-                    break;
-            }
-            return image;
-        };
-
-        std::unique_ptr<IEncodedImage> image;
-
-        for (const std::string_view filename : preferredFileNames)
-        {
-            image = tryLoadImageFromFilename(filename);
-            if (image)
-                return image;
-        }
-
-        if (allowPickRandom)
-        {
-            for (const auto& [filename, coverPath] : coverPaths)
-            {
-                image = getFromCoverFile(coverPath, width);
-                if (image)
-                    return image;
-            }
-        }
-
-        return image;
-    }
-
-    std::unique_ptr<IEncodedImage> CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
-    {
-        std::unique_ptr<IEncodedImage> res;
-
-        std::filesystem::path coverPath{ filePath };
-        for (const std::filesystem::path& extension : _fileExtensions)
-        {
-            coverPath.replace_extension(extension);
-
-            if (!checkCoverFile(coverPath))
-                continue;
-
-            res = getFromCoverFile(coverPath, width);
-            if (res)
-                break;
-        }
-
-        return res;
-    }
-
-    bool CoverService::checkCoverFile(const std::filesystem::path& filePath) const
+    bool CoverService::checkImageFile(const std::filesystem::path& filePath) const
     {
         std::error_code ec;
 
@@ -235,35 +124,9 @@ namespace lms::cover
         if (!std::filesystem::is_regular_file(filePath, ec))
             return false;
 
-        if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec)
-        {
-            LMS_LOG(COVER, INFO, "Image file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize);
-            return false;
-        }
-
         return true;
     }
 
-    std::multimap<std::string, std::filesystem::path> CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
-    {
-        std::multimap<std::string, std::filesystem::path> res;
-        std::error_code ec;
-
-        std::filesystem::directory_iterator itPath(directoryPath, ec);
-        const std::filesystem::directory_iterator itEnd;
-        while (!ec && itPath != itEnd)
-        {
-            const std::filesystem::path& path{ *itPath };
-
-            if (checkCoverFile(path))
-                res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
-
-            itPath.increment(ec);
-        }
-
-        return res;
-    }
-
     std::unique_ptr<IEncodedImage> CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
     {
         std::unique_ptr<IEncodedImage> image;
@@ -282,35 +145,19 @@ namespace lms::cover
 
     std::shared_ptr<IEncodedImage> CoverService::getFromTrack(db::TrackId trackId, ImageSize width)
     {
-        return getFromTrack(_db.getTLSSession(), trackId, width, true /* allow release fallback*/);
-    }
-
-    std::shared_ptr<IEncodedImage> CoverService::getFromTrack(db::Session& dbSession, db::TrackId trackId, ImageSize width, bool allowReleaseFallback)
-    {
-        using namespace db;
-
         const ImageCache::EntryDesc cacheEntryDesc{ trackId, width };
 
         std::shared_ptr<IEncodedImage> cover{ _cache.getImage(cacheEntryDesc) };
         if (cover)
             return cover;
 
-        if (const std::optional<TrackInfo> trackInfo{ getTrackInfo(dbSession, trackId) })
         {
-            if (trackInfo->hasCover)
-                cover = getFromTrack(trackInfo->trackPath, width);
+            db::Session& session{ _db.getTLSSession() };
+            auto transaction{ session.createReadTransaction() };
 
-            if (!cover)
-                cover = getFromSameNamedFile(trackInfo->trackPath, width);
-
-            if (!cover && trackInfo->releaseId && allowReleaseFallback)
-                cover = getFromRelease(*trackInfo->releaseId, width);
-
-            if (!cover && trackInfo->isMultiDisc)
-            {
-                if (trackInfo->trackPath.parent_path().has_parent_path())
-                    cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width, _preferredFileNames, true);
-            }
+            const db::Track::pointer track{ db::Track::find(session, trackId) };
+            if (track && track->hasCover())
+                cover = getFromTrack(track->getAbsoluteFilePath(), width);
         }
 
         if (cover)
@@ -324,47 +171,26 @@ namespace lms::cover
         using namespace db;
         const ImageCache::EntryDesc cacheEntryDesc{ releaseId, width };
 
-        std::shared_ptr<IEncodedImage> cover{ _cache.getImage(cacheEntryDesc) };
-        if (cover)
-            return cover;
+        std::shared_ptr<IEncodedImage> image{ _cache.getImage(cacheEntryDesc) };
+        if (image)
+            return image;
 
-        struct ReleaseInfo
         {
-            TrackId firstTrackId;
-            std::filesystem::path releaseDirectory;
-        };
-
-        Session& session{ _db.getTLSSession() };
-
-        auto getReleaseInfo{ [&] {
-            std::optional<ReleaseInfo> res;
-
+            Session& session{ _db.getTLSSession() };
             auto transaction{ session.createReadTransaction() };
 
-            // get a track in this release, consider the release is in a single directory
-            const auto tracks{ Track::find(session, Track::FindParameters{}.setRelease(releaseId).setRange(Range{ 0, 1 }).setSortMethod(TrackSortMethod::Release)) };
-            if (!tracks.results.empty())
+            const db::Release::pointer release{ db::Release::find(session, releaseId) };
+            if (release)
             {
-                const Track::pointer& track{ tracks.results.front() };
-                res = ReleaseInfo{};
-                res->firstTrackId = track->getId();
-                res->releaseDirectory = track->getAbsoluteFilePath().parent_path();
+                if (const db::Image::pointer dbImage{ release->getImage() })
+                    image = getFromImageFile(dbImage->getAbsoluteFilePath(), width);
             }
-
-            return res;
-        } };
-
-        if (const std::optional<ReleaseInfo> releaseInfo{ getReleaseInfo() })
-        {
-            cover = getFromDirectory(releaseInfo->releaseDirectory, width, _preferredFileNames, true);
-            if (!cover)
-                cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */);
         }
 
-        if (cover)
-            _cache.addImage(cacheEntryDesc, cover);
+        if (image)
+            _cache.addImage(cacheEntryDesc, image);
 
-        return cover;
+        return image;
     }
 
     std::shared_ptr<IEncodedImage> CoverService::getFromArtist(db::ArtistId artistId, ImageSize width)
@@ -384,7 +210,7 @@ namespace lms::cover
             if (const Artist::pointer artist{ Artist::find(session, artistId) })
             {
                 if (const db::Image::pointer image{ artist->getImage() })
-                    artistImage = getFromCoverFile(image->getAbsoluteFilePath(), width);
+                    artistImage = getFromImageFile(image->getAbsoluteFilePath(), width);
             }
         }
 
diff --git a/src/libs/services/cover/impl/CoverService.hpp b/src/libs/services/cover/impl/CoverService.hpp
index a5899bc4..1587a073 100644
--- a/src/libs/services/cover/impl/CoverService.hpp
+++ b/src/libs/services/cover/impl/CoverService.hpp
@@ -20,7 +20,6 @@
 #pragma once
 
 #include <filesystem>
-#include <map>
 #include <vector>
 
 #include "database/Types.hpp"
@@ -59,14 +58,11 @@ namespace lms::cover
 
         std::shared_ptr<image::IEncodedImage> getFromTrack(db::Session& dbSession, db::TrackId trackId, image::ImageSize width, bool allowReleaseFallback);
         std::unique_ptr<image::IEncodedImage> getFromAvMediaFile(const av::IAudioFile& input, image::ImageSize width) const;
-        std::unique_ptr<image::IEncodedImage> getFromCoverFile(const std::filesystem::path& p, image::ImageSize width) const;
+        std::unique_ptr<image::IEncodedImage> getFromImageFile(const std::filesystem::path& p, image::ImageSize width) const;
 
         std::unique_ptr<image::IEncodedImage> getFromTrack(const std::filesystem::path& path, image::ImageSize width) const;
-        std::multimap<std::string, std::filesystem::path> getCoverPaths(const std::filesystem::path& directoryPath) const;
-        std::unique_ptr<image::IEncodedImage> getFromDirectory(const std::filesystem::path& directory, image::ImageSize width, const std::vector<std::string>& preferredFileNames, bool allowPickRandom) const;
-        std::unique_ptr<image::IEncodedImage> getFromSameNamedFile(const std::filesystem::path& filePath, image::ImageSize width) const;
 
-        bool checkCoverFile(const std::filesystem::path& filePath) const;
+        bool checkImageFile(const std::filesystem::path& filePath) const;
 
         db::Db& _db;
 
@@ -74,8 +70,6 @@ namespace lms::cover
         std::shared_ptr<image::IEncodedImage> _defaultCover;
 
         static inline const std::vector<std::filesystem::path> _fileExtensions{ ".jpg", ".jpeg", ".png", ".bmp" }; // TODO parametrize
-        const std::size_t _maxFileSize;
-        const std::vector<std::string> _preferredFileNames;
         unsigned _jpegQuality;
     };
 
diff --git a/src/libs/services/cover/include/services/cover/ICoverService.hpp b/src/libs/services/cover/include/services/cover/ICoverService.hpp
index cbed5e7f..bf0f6c57 100644
--- a/src/libs/services/cover/include/services/cover/ICoverService.hpp
+++ b/src/libs/services/cover/include/services/cover/ICoverService.hpp
@@ -39,10 +39,14 @@ namespace lms::cover
     public:
         virtual ~ICoverService() = default;
 
-        virtual std::shared_ptr<image::IEncodedImage> getFromTrack(db::TrackId trackId, image::ImageSize width) = 0;
-        virtual std::shared_ptr<image::IEncodedImage> getFromRelease(db::ReleaseId releaseId, image::ImageSize width) = 0;
         virtual std::shared_ptr<image::IEncodedImage> getFromArtist(db::ArtistId artistId, image::ImageSize width) = 0;
 
+        // no logic to fallback to release here
+        virtual std::shared_ptr<image::IEncodedImage> getFromTrack(db::TrackId trackId, image::ImageSize width) = 0;
+
+        // no logic to fallback to track here
+        virtual std::shared_ptr<image::IEncodedImage> getFromRelease(db::ReleaseId releaseId, image::ImageSize width) = 0;
+
         virtual std::shared_ptr<image::IEncodedImage> getDefaultSvgCover() = 0;
 
         virtual void flushCache() = 0;
diff --git a/src/libs/services/scanner/CMakeLists.txt b/src/libs/services/scanner/CMakeLists.txt
index 00af758d..a0fdc56a 100644
--- a/src/libs/services/scanner/CMakeLists.txt
+++ b/src/libs/services/scanner/CMakeLists.txt
@@ -4,6 +4,7 @@ add_library(lmsscanner SHARED
 	impl/ScannerService.cpp
 	impl/ScannerStats.cpp
 	impl/ScanStepAssociateArtistImages.cpp
+	impl/ScanStepAssociateReleaseImages.cpp
 	impl/ScanStepCheckForDuplicatedFiles.cpp
 	impl/ScanStepCheckForRemovedFiles.cpp
 	impl/ScanStepCompact.cpp
diff --git a/src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.cpp b/src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.cpp
new file mode 100644
index 00000000..b44b35ae
--- /dev/null
+++ b/src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (C) 2024 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ScanStepAssociateReleaseImages.hpp"
+
+#include <array>
+#include <cassert>
+#include <deque>
+#include <set>
+
+#include "core/IConfig.hpp"
+#include "core/ILogger.hpp"
+#include "core/Path.hpp"
+#include "database/Db.hpp"
+#include "database/Directory.hpp"
+#include "database/Image.hpp"
+#include "database/Release.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "image/Exception.hpp"
+#include "image/Image.hpp"
+
+namespace lms::scanner
+{
+    namespace
+    {
+        constexpr std::size_t readBatchSize{ 100 };
+        constexpr std::size_t writeBatchSize{ 10 };
+
+        struct ReleaseImageAssociation
+        {
+            db::ReleaseId releaseId;
+            db::ImageId imageId;
+        };
+        using ReleaseImageAssociationContainer = std::deque<ReleaseImageAssociation>;
+
+        struct SearchImageContext
+        {
+            db::Session& session;
+            db::ReleaseId lastRetrievedReleaseId;
+            const std::vector<std::string>& releaseFileNames;
+        };
+
+        db::Image::pointer findImageInDirectory(SearchImageContext& searchContext, const std::filesystem::path& directoryPath)
+        {
+            db::Image::pointer image;
+
+            const db::Directory::pointer directory{ db::Directory::find(searchContext.session, directoryPath) };
+            if (directory) // may not exist for releases that are split on different media libraries
+            {
+                for (std::string_view fileStem : searchContext.releaseFileNames)
+                {
+                    db::Image::FindParameters params;
+                    params.setDirectory(directory->getId());
+                    params.setFileStem(fileStem);
+
+                    db::Image::find(searchContext.session, params, [&](const db::Image::pointer foundImg) {
+                        if (!image)
+                            image = foundImg;
+                    });
+
+                    if (image)
+                        break;
+                }
+            }
+
+            return image;
+        }
+
+        db::Image::pointer computeBestReleaseImage(SearchImageContext& searchContext, const db::Release::pointer& release)
+        {
+            db::Image::pointer image;
+
+            const auto mbid{ release->getMBID() };
+            if (mbid)
+            {
+                // Find anywhere, since it is suppoed to be unique!
+                db::Image::find(searchContext.session, db::Image::FindParameters{}.setFileStem(mbid->getAsString()), [&](const db::Image::pointer foundImg) {
+                    if (!image)
+                        image = foundImg;
+                });
+            }
+
+            if (!image)
+            {
+                std::set<std::filesystem::path> releasePaths;
+                db::Directory::FindParameters params;
+                params.setRelease(release->getId());
+
+                db::Directory::find(searchContext.session, params, [&](const db::Directory::pointer& directory) {
+                    releasePaths.insert(directory->getAbsolutePath());
+                });
+
+                // Expect layout like this:
+                // Artist/Release/CD1/...
+                //               /CD2/...
+                //               /cover.jpg
+                if (releasePaths.size() > 1)
+                {
+                    const std::filesystem::path releasePath{ core::pathUtils::getLongestCommonPath(std::cbegin(releasePaths), std::cend(releasePaths)) };
+                    image = findImageInDirectory(searchContext, releasePath);
+                }
+
+                if (!image)
+                {
+                    for (const std::filesystem::path& releasePath : releasePaths)
+                    {
+                        image = findImageInDirectory(searchContext, releasePath);
+                        if (image)
+                            break;
+                    }
+                }
+            }
+
+            return image;
+        }
+
+        bool fetchNextReleaseImagesToUpdate(SearchImageContext& searchContext, ReleaseImageAssociationContainer& releaseImageAssociations)
+        {
+            const db::ReleaseId releaseId{ searchContext.lastRetrievedReleaseId };
+
+            {
+                auto transaction{ searchContext.session.createReadTransaction() };
+
+                db::Release::find(searchContext.session, searchContext.lastRetrievedReleaseId, readBatchSize, [&](const db::Release::pointer& release) {
+                    db::Image::pointer image{ computeBestReleaseImage(searchContext, release) };
+
+                    if (image != release->getImage())
+                    {
+                        LMS_LOG(DBUPDATER, DEBUG, "Updating release image for release '" << release->getName() << "', using '" << (image ? image->getAbsoluteFilePath().c_str() : "<none>") << "'");
+                        releaseImageAssociations.push_back(ReleaseImageAssociation{ release->getId(), image ? image->getId() : db::ImageId{} });
+                    }
+                });
+            }
+
+            return releaseId != searchContext.lastRetrievedReleaseId;
+        }
+
+        void updateReleaseImage(db::Session& session, const ReleaseImageAssociation& releaseImageAssociation)
+        {
+            db::Release::pointer release{ db::Release::find(session, releaseImageAssociation.releaseId) };
+            assert(release);
+
+            db::Image::pointer image;
+            if (releaseImageAssociation.imageId.isValid())
+                image = db::Image::find(session, releaseImageAssociation.imageId);
+
+            release.modify()->setImage(image);
+        }
+
+        void updateReleaseImages(db::Session& session, ReleaseImageAssociationContainer& imageAssociations)
+        {
+            if (imageAssociations.empty())
+                return;
+
+            auto transaction{ session.createWriteTransaction() };
+
+            for (std::size_t i{}; !imageAssociations.empty() && i < writeBatchSize; ++i)
+            {
+                updateReleaseImage(session, imageAssociations.front());
+                imageAssociations.pop_front();
+            }
+        }
+
+        std::vector<std::string> constructReleaseFileNames()
+        {
+            std::vector<std::string> res;
+
+            core::Service<core::IConfig>::get()->visitStrings("cover-preferred-file-names",
+                [&res](std::string_view fileName) {
+                    res.emplace_back(fileName);
+                },
+                { "cover", "front", "folder", "default" });
+
+            return res;
+        }
+
+    } // namespace
+
+    ScanStepAssociateReleaseImages::ScanStepAssociateReleaseImages(InitParams& initParams)
+        : ScanStepBase{ initParams }
+        , _releaseFileNames{ constructReleaseFileNames() }
+    {
+    }
+
+    void ScanStepAssociateReleaseImages::process(ScanContext& context)
+    {
+        if (_abortScan)
+            return;
+
+        if (context.stats.nbChanges() == 0)
+            return;
+
+        auto& session{ _db.getTLSSession() };
+
+        {
+            auto transaction{ session.createReadTransaction() };
+            context.currentStepStats.totalElems = db::Release::getCount(session);
+        }
+
+        SearchImageContext searchContext{
+            .session = session,
+            .lastRetrievedReleaseId = {},
+            .releaseFileNames = _releaseFileNames,
+        };
+
+        ReleaseImageAssociationContainer releaseImageAssociations;
+        while (fetchNextReleaseImagesToUpdate(searchContext, releaseImageAssociations))
+        {
+            if (_abortScan)
+                return;
+
+            updateReleaseImages(session, releaseImageAssociations);
+            context.currentStepStats.processedElems += readBatchSize;
+            _progressCallback(context.currentStepStats);
+        }
+    }
+} // namespace lms::scanner
diff --git a/src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.hpp b/src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.hpp
new file mode 100644
index 00000000..439d61d9
--- /dev/null
+++ b/src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.hpp
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2024 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "ScanStepBase.hpp"
+
+namespace lms::scanner
+{
+    class ScanStepAssociateReleaseImages : public ScanStepBase
+    {
+    public:
+        ScanStepAssociateReleaseImages(InitParams& initParams);
+
+    private:
+        ScanStep getStep() const override { return ScanStep::AssociateArtistImages; }
+        core::LiteralString getStepName() const override { return "Associate release images"; }
+        void process(ScanContext& context) override;
+
+        const std::vector<std::string> _releaseFileNames;
+    };
+} // namespace lms::scanner
diff --git a/src/libs/services/scanner/impl/ScannerService.cpp b/src/libs/services/scanner/impl/ScannerService.cpp
index e9810f89..437bfff0 100644
--- a/src/libs/services/scanner/impl/ScannerService.cpp
+++ b/src/libs/services/scanner/impl/ScannerService.cpp
@@ -32,6 +32,7 @@
 #include "image/Image.hpp"
 
 #include "ScanStepAssociateArtistImages.hpp"
+#include "ScanStepAssociateReleaseImages.hpp"
 #include "ScanStepCheckForDuplicatedFiles.hpp"
 #include "ScanStepCheckForRemovedFiles.hpp"
 #include "ScanStepCompact.hpp"
@@ -347,6 +348,7 @@ namespace lms::scanner
         _scanSteps.push_back(std::make_unique<ScanStepCheckForRemovedFiles>(params));
         _scanSteps.push_back(std::make_unique<ScanStepUpdateLibraryFields>(params));
         _scanSteps.push_back(std::make_unique<ScanStepAssociateArtistImages>(params));
+        _scanSteps.push_back(std::make_unique<ScanStepAssociateReleaseImages>(params));
         _scanSteps.push_back(std::make_unique<ScanStepRemoveOrphanedDbEntries>(params));
         _scanSteps.push_back(std::make_unique<ScanStepCompact>(params));
         _scanSteps.push_back(std::make_unique<ScanStepOptimize>(params));
diff --git a/src/libs/services/scanner/include/services/scanner/ScannerStats.hpp b/src/libs/services/scanner/include/services/scanner/ScannerStats.hpp
index f92a6c19..e3fc37f6 100644
--- a/src/libs/services/scanner/include/services/scanner/ScannerStats.hpp
+++ b/src/libs/services/scanner/include/services/scanner/ScannerStats.hpp
@@ -62,6 +62,7 @@ namespace lms::scanner
     enum class ScanStep
     {
         AssociateArtistImages,
+        AssociateReleaseImages,
         CheckForDuplicatedFiles,
         CheckForRemovedFiles,
         ComputeClusterStats,
diff --git a/src/libs/subsonic/impl/responses/Album.cpp b/src/libs/subsonic/impl/responses/Album.cpp
index ad4404ff..9d7666eb 100644
--- a/src/libs/subsonic/impl/responses/Album.cpp
+++ b/src/libs/subsonic/impl/responses/Album.cpp
@@ -25,7 +25,9 @@
 #include "database/Artist.hpp"
 #include "database/Cluster.hpp"
 #include "database/Directory.hpp"
+#include "database/Image.hpp"
 #include "database/Release.hpp"
+#include "database/Track.hpp"
 #include "database/User.hpp"
 #include "services/feedback/IFeedbackService.hpp"
 #include "services/scrobbling/IScrobblingService.hpp"
@@ -82,7 +84,21 @@ namespace lms::api::subsonic
         }
 
         albumNode.setAttribute("created", core::stringUtils::toISO8601String(release->getLastWritten()));
-        albumNode.setAttribute("coverArt", idToString(release->getId()));
+        if (release->getImage())
+        {
+            albumNode.setAttribute("coverArt", idToString(release->getId()));
+        }
+        else
+        {
+            db::Track::FindParameters params;
+            params.setRelease(release->getId());
+            params.setHasEmbeddedImage(true);
+            params.setRange(db::Range{ 0, 1 });
+
+            db::Track::find(context.dbSession, params, [&](const db::Track::pointer& track) {
+                albumNode.setAttribute("coverArt", idToString(track->getId()));
+            });
+        }
         if (const auto year{ release->getYear() })
             albumNode.setAttribute("year", *year);
 
diff --git a/src/libs/subsonic/impl/responses/Artist.cpp b/src/libs/subsonic/impl/responses/Artist.cpp
index e7e1db67..116d58e7 100644
--- a/src/libs/subsonic/impl/responses/Artist.cpp
+++ b/src/libs/subsonic/impl/responses/Artist.cpp
@@ -94,7 +94,7 @@ namespace lms::api::subsonic
 
         artistNode.setAttribute("id", idToString(artist->getId()));
         artistNode.setAttribute("name", artist->getName());
-        if (const db::Image::pointer artistImage{ artist->getImage() })
+        if (artist->getImage())
             artistNode.setAttribute("coverArt", idToString(artist->getId()));
 
         const std::size_t count{ Release::getCount(context.dbSession, Release::FindParameters{}.setArtist(artist->getId())) };
diff --git a/src/libs/subsonic/impl/responses/Playlist.cpp b/src/libs/subsonic/impl/responses/Playlist.cpp
index b0e2e9bb..4aa0842b 100644
--- a/src/libs/subsonic/impl/responses/Playlist.cpp
+++ b/src/libs/subsonic/impl/responses/Playlist.cpp
@@ -31,7 +31,7 @@ namespace lms::api::subsonic
 
     static const std::string_view reportedDummyDate{ "2000-01-01T00:00:00" };
 
-    Response::Node createPlaylistNode(const TrackList::pointer& tracklist, Session&)
+    Response::Node createPlaylistNode(const TrackList::pointer& tracklist, Session& session)
     {
         Response::Node playlistNode;
 
@@ -43,8 +43,15 @@ namespace lms::api::subsonic
         playlistNode.setAttribute("created", reportedDummyDate);
         playlistNode.setAttribute("owner", tracklist->getUser()->getLoginName());
 
-        if (const auto entry{ tracklist->getEntry(0) })
-            playlistNode.setAttribute("coverArt", idToString(entry->getTrack()->getId()));
+        db::Track::FindParameters params;
+        params.setTrackList(tracklist->getId());
+        params.setHasEmbeddedImage(true);
+        params.setRange(db::Range{ 0, 1 });
+        params.setSortMethod(TrackSortMethod::TrackList);
+
+        db::Track::find(session, params, [&](const db::Track::pointer& track) {
+            playlistNode.setAttribute("coverArt", idToString(track->getId()));
+        });
 
         return playlistNode;
     }
diff --git a/src/libs/subsonic/impl/responses/Song.cpp b/src/libs/subsonic/impl/responses/Song.cpp
index 0bb8fb6c..acc4975f 100644
--- a/src/libs/subsonic/impl/responses/Song.cpp
+++ b/src/libs/subsonic/impl/responses/Song.cpp
@@ -28,6 +28,7 @@
 #include "database/Artist.hpp"
 #include "database/Cluster.hpp"
 #include "database/Directory.hpp"
+#include "database/Image.hpp"
 #include "database/Release.hpp"
 #include "database/Track.hpp"
 #include "database/TrackArtistLink.hpp"
@@ -110,7 +111,7 @@ namespace lms::api::subsonic
 
         if (track->hasCover())
             trackResponse.setAttribute("coverArt", idToString(track->getId()));
-        else if (release)
+        else if (release && release->getImage())
             trackResponse.setAttribute("coverArt", idToString(release->getId()));
 
         const std::vector<Artist::pointer>& artists{ track->getArtists({ TrackArtistLinkType::Artist }) };
diff --git a/src/lms/ui/Utils.cpp b/src/lms/ui/Utils.cpp
index 216dc518..8bf98c5e 100644
--- a/src/lms/ui/Utils.cpp
+++ b/src/lms/ui/Utils.cpp
@@ -27,6 +27,7 @@
 
 #include "database/Artist.hpp"
 #include "database/Cluster.hpp"
+#include "database/Image.hpp"
 #include "database/Release.hpp"
 #include "database/ScanSettings.hpp"
 #include "database/Session.hpp"
@@ -65,7 +66,36 @@ namespace lms::ui::utils
     std::unique_ptr<Wt::WImage> createCover(db::ReleaseId releaseId, CoverResource::Size size)
     {
         auto cover{ std::make_unique<Wt::WImage>() };
-        cover->setImageLink(LmsApp->getCoverResource()->getReleaseUrl(releaseId, size));
+        std::string internalUrl;
+
+        {
+            auto transaction{ LmsApp->getDbSession().createReadTransaction() };
+
+            const db::Release::pointer release{ db::Release::find(LmsApp->getDbSession(), releaseId) };
+            if (release)
+            {
+                if (release->getImage())
+                {
+                    internalUrl = LmsApp->getCoverResource()->getReleaseUrl(release->getId(), size);
+                }
+                else
+                {
+                    db::Track::FindParameters params;
+                    params.setRelease(releaseId);
+                    params.setHasEmbeddedImage(true);
+                    params.setRange(db::Range{ 0, 1 });
+
+                    db::Track::find(LmsApp->getDbSession(), params, [&](const db::Track::pointer& track) {
+                        internalUrl = LmsApp->getCoverResource()->getTrackUrl(track->getId(), size);
+                    });
+                }
+            }
+        }
+
+        if (internalUrl.empty())
+            internalUrl = LmsApp->getCoverResource()->getDefaultUrl(size);
+
+        cover->setImageLink(internalUrl);
         cover->setStyleClass("Lms-cover img-fluid");                                          // HACK
         cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
         return cover;
@@ -74,9 +104,28 @@ namespace lms::ui::utils
     std::unique_ptr<Wt::WImage> createCover(db::TrackId trackId, CoverResource::Size size)
     {
         auto cover{ std::make_unique<Wt::WImage>() };
-        cover->setImageLink(LmsApp->getCoverResource()->getTrackUrl(trackId, size));
+        std::string internalUrl;
+
+        {
+            auto transaction{ LmsApp->getDbSession().createReadTransaction() };
+
+            const db::Track::pointer track{ db::Track::find(LmsApp->getDbSession(), trackId) };
+            if (track)
+            {
+                if (track->hasCover())
+                    internalUrl = LmsApp->getCoverResource()->getTrackUrl(trackId, size);
+                else if (const db::Release::pointer release{ track->getRelease() }; release && release->getImage())
+                    internalUrl = LmsApp->getCoverResource()->getReleaseUrl(release->getId(), size);
+            }
+        }
+
+        if (internalUrl.empty())
+            internalUrl = LmsApp->getCoverResource()->getDefaultUrl(size);
+
+        cover->setImageLink(internalUrl);
         cover->setStyleClass("Lms-cover img-fluid");                                          // HACK
         cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
+
         return cover;
     }
 
diff --git a/src/lms/ui/admin/ScannerController.cpp b/src/lms/ui/admin/ScannerController.cpp
index 42f5b0d8..0289e157 100644
--- a/src/lms/ui/admin/ScannerController.cpp
+++ b/src/lms/ui/admin/ScannerController.cpp
@@ -274,6 +274,11 @@ namespace lms::ui
                                      .arg(stepStats.progress()));
             break;
 
+        case ScanStep::AssociateReleaseImages:
+            _stepStatus->setText(Wt::WString::tr("Lms.Admin.ScannerController.step-associating-release-images")
+                                     .arg(stepStats.progress()));
+            break;
+
         case ScanStep::CheckForDuplicatedFiles:
             _stepStatus->setText(Wt::WString::tr("Lms.Admin.ScannerController.step-checking-for-duplicate-files")
                                      .arg(stepStats.processedElems));
diff --git a/src/lms/ui/resource/CoverResource.cpp b/src/lms/ui/resource/CoverResource.cpp
index 28ea9b0a..5c8d14ee 100644
--- a/src/lms/ui/resource/CoverResource.cpp
+++ b/src/lms/ui/resource/CoverResource.cpp
@@ -59,6 +59,11 @@ namespace lms::ui
         return url() + "&trackid=" + trackId.toString() + "&size=" + std::to_string(static_cast<std::size_t>(size));
     }
 
+    std::string CoverResource::getDefaultUrl(Size size) const
+    {
+        return url() + "&size=" + std::to_string(static_cast<std::size_t>(size));
+    }
+
     void CoverResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
     {
         LMS_SCOPED_TRACE_OVERVIEW("UI", "HandleCoverRequest");
@@ -96,8 +101,6 @@ namespace lms::ui
             }
 
             cover = core::Service<cover::ICoverService>::get()->getFromTrack(*trackId, *size);
-            if (!cover)
-                cover = core::Service<cover::ICoverService>::get()->getDefaultSvgCover();
         }
         else if (releaseIdStr)
         {
@@ -108,14 +111,12 @@ namespace lms::ui
                 return;
 
             cover = core::Service<cover::ICoverService>::get()->getFromRelease(*releaseId, *size);
-            if (!cover)
-                cover = core::Service<cover::ICoverService>::get()->getDefaultSvgCover();
         }
         else
-        {
-            LOG(DEBUG, "No track or release provided");
-            return;
-        }
+            LOG(DEBUG, "Requested default cover");
+
+        if (!cover)
+            cover = core::Service<cover::ICoverService>::get()->getDefaultSvgCover();
 
         response.setMimeType(std::string{ cover->getMimeType() });
 
diff --git a/src/lms/ui/resource/CoverResource.hpp b/src/lms/ui/resource/CoverResource.hpp
index d0ebc8a0..b75772d5 100644
--- a/src/lms/ui/resource/CoverResource.hpp
+++ b/src/lms/ui/resource/CoverResource.hpp
@@ -42,6 +42,7 @@ namespace lms::ui
 
         std::string getReleaseUrl(db::ReleaseId releaseId, Size size) const;
         std::string getTrackUrl(db::TrackId trackId, Size size) const;
+        std::string getDefaultUrl(Size size) const;
 
     private:
         void handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response) override;