diff --git a/module/applications/sheets/actors/character.mjs b/module/applications/sheets/actors/character.mjs
index f40c144a..2a557411 100644
--- a/module/applications/sheets/actors/character.mjs
+++ b/module/applications/sheets/actors/character.mjs
@@ -718,7 +718,7 @@ export default class CharacterSheet extends DHBaseActorSheet {
                     ? {
                           'system.linkedClass.uuid': {
                               key: 'system.linkedClass.uuid',
-                              value: this.document.system.class.value._stats.compendiumSource
+                              value: this.document.system.class.value?._stats.compendiumSource
                           }
                       }
                     : undefined,
diff --git a/module/data/item/subclass.mjs b/module/data/item/subclass.mjs
index 12d85c1e..ecf72de3 100644
--- a/module/data/item/subclass.mjs
+++ b/module/data/item/subclass.mjs
@@ -56,38 +56,30 @@ export default class DHSubclass extends BaseDataItem {
         if (allowed === false) return;
 
         if (this.actor?.type === 'character') {
-            const dataUuid = data.uuid ?? data._stats.compendiumSource ?? `Item.${data._id}`;
-            if (this.actor.system.class.subclass) {
-                if (this.actor.system.multiclass.subclass) {
-                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.subclassesAlreadyPresent'));
-                    return false;
-                } else {
-                    const multiclass = this.actor.items.find(x => x.type === 'class' && x.system.isMulticlass);
-                    if (!multiclass) {
-                        ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.missingMulticlass'));
-                        return false;
-                    }
+            const { value: actorClass, subclass: existingSubclass } = this.actor.system.class;
+            const { value: multiclass, subclass: existingMultisubclass } = this.actor.system.multiclass;
+            if (!actorClass && !multiclass) {
+                ui.notifications.warn('DAGGERHEART.UI.Notifications.missingClass', { localize: true });
+                return false;
+            }
+            if (existingSubclass && existingMultisubclass) {
+                ui.notifications.warn('DAGGERHEART.UI.Notifications.subclassesAlreadyPresent', { localize: true });
+                return false;
+            }
+            if (existingSubclass && !multiclass) {
+                ui.notifications.warn('DAGGERHEART.UI.Notifications.missingMulticlass', { localize: true });
+                return false;
+            }
 
-                    if (multiclass.system.subclasses.every(x => x.uuid !== dataUuid)) {
-                        ui.notifications.error(
-                            game.i18n.localize('DAGGERHEART.UI.Notifications.subclassNotInMulticlass')
-                        );
-                        return false;
-                    }
-
-                    await this.updateSource({ isMulticlass: true });
-                }
-            } else {
-                const actorClass = this.actor.items.find(x => x.type === 'class' && !x.system.isMulticlass);
-                if (!actorClass) {
-                    ui.notifications.warn(game.i18n.localize('DAGGERHEART.UI.Notifications.missingClass'));
-                    return false;
-                }
-
-                if ((await actorClass.system.fetchSubclasses()).every(x => x.uuid !== dataUuid)) {
-                    ui.notifications.error(game.i18n.localize('DAGGERHEART.UI.Notifications.subclassNotInClass'));
-                    return false;
-                }
+            const match = [multiclass, actorClass].find(
+                c => c && (c._stats.compendiumSource ?? c.uuid) === this.linkedClass
+            );
+            if (!match) {
+                const key = multiclass ? 'subclassNotInMulticlass' : 'subclassNotInClass';
+                ui.notifications.warn(`DAGGERHEART.UI.Notifications.${key}`, { localize: true });
+                return false;
+            } else if (match.system.isMulticlass) {
+                await this.updateSource({ isMulticlass: true });
             }
         }
     }
diff --git a/module/documents/actor.mjs b/module/documents/actor.mjs
index 91bf7190..c1c9aca9 100644
--- a/module/documents/actor.mjs
+++ b/module/documents/actor.mjs
@@ -281,6 +281,7 @@ export default class DhpActor extends Actor {
 
     async levelUp(levelupData) {
         const levelupAuto = game.settings.get(CONFIG.DH.id, CONFIG.DH.SETTINGS.gameSettings.Automation).levelupAuto;
+        const getStatsWithSource = document => ({ ...(document._stats ?? {}), compendiumSource: document.uuid });
 
         const levelups = {};
         for (var levelKey of Object.keys(levelupData)) {
@@ -393,8 +394,7 @@ export default class DhpActor extends Actor {
                     const embeddedItem = await this.createEmbeddedDocuments('Item', [
                         {
                             ...multiclassData,
-                            uuid: multiclassItem.uuid,
-                            _stats: multiclassItem._stats,
+                            _stats: getStatsWithSource(multiclassItem),
                             system: {
                                 ...multiclassData.system,
                                 features: multiclassData.system.features.filter(x => x.type !== 'hope'),
@@ -407,8 +407,7 @@ export default class DhpActor extends Actor {
                     await this.createEmbeddedDocuments('Item', [
                         {
                             ...subclassData,
-                            uuid: subclassItem.uuid,
-                            _stats: subclassItem._stats,
+                            _stats: getStatsWithSource(subclassItem),
                             system: {
                                 ...subclassData.system,
                                 isMulticlass: true
@@ -428,8 +427,7 @@ export default class DhpActor extends Actor {
                     const embeddedItem = await this.createEmbeddedDocuments('Item', [
                         {
                             ...cardData,
-                            uuid: cardItem.uuid,
-                            _stats: cardItem._stats,
+                            _stats: getStatsWithSource(cardItem),
                             system: {
                                 ...cardData.system,
                                 inVault: true
@@ -450,8 +448,7 @@ export default class DhpActor extends Actor {
                     const embeddedItem = await this.createEmbeddedDocuments('Item', [
                         {
                             ...cardData,
-                            uuid: cardItem.uuid,
-                            _stats: cardItem._stats,
+                            _stats: getStatsWithSource(cardItem),
                             system: {
                                 ...cardData.system,
                                 inVault: true