diff --git a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbMappings.java b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbMappings.java
index b399eb8..21a2384 100644
--- a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbMappings.java
+++ b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/JsonbMappings.java
@@ -49,7 +49,6 @@
         }
 
         polymorphismHandler.validateJsonbPolymorphismAnnotations(original.clazz);
-        polymorphismHandler.populateTypeInfoCache(original.clazz);
         return new ClassMapping(
                 original.clazz, original.factory, original.getters, original.setters,
                 original.adapter, original.reader, original.writer, original.anyGetter,
diff --git a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismHandler.java b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismHandler.java
index 36f1aed..48a5de6 100644
--- a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismHandler.java
+++ b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismHandler.java
@@ -38,47 +38,46 @@
     private final Map<Class<?>, JsonbPolymorphismTypeInfo> typeInfoCache = new HashMap<>();
 
     public boolean hasPolymorphism(Class<?> clazz) {
-        return Meta.getAnnotation((AnnotatedElement) clazz, JsonbTypeInfo.class) != null || getParentWithTypeInfo(clazz) != null;
+        return getOrCreatePolymorphismTypeInfo(clazz) != null;
     }
 
     public Map.Entry<String, String>[] getPolymorphismPropertiesToSerialize(Class<?> clazz, Collection<String> otherProperties) {
         List<Map.Entry<String, String>> result = new ArrayList<>();
 
-        Class<?> current = clazz;
-        while (current != null) {
-            // Only try to resolve types when there's a JsonbTypeInfo Annotation present on the current type, Meta.getAnnotation tries to
-            // walk up parents by itself until it finds the given Annotation and could incorrectly cause JsonbExceptions to be thrown
-            // (multiple JsonbTypeInfos with same key found even if thats not actually the case)
-            JsonbTypeInfo typeInfo = Meta.getAnnotation((AnnotatedElement) current, JsonbTypeInfo.class);
-            if (typeInfo != null) {
-                if (otherProperties.contains(typeInfo.key())) {
-                    throw new JsonbException("JsonbTypeInfo key '" + typeInfo.key() + "' collides with other properties in json");
+        JsonbPolymorphismTypeInfo polymorphismTypeInfo = getOrCreatePolymorphismTypeInfo(clazz);
+        while (polymorphismTypeInfo != null) {
+            if (polymorphismTypeInfo.hasSubtypeInformation()) {
+                if (otherProperties.contains(polymorphismTypeInfo.getTypeKey())) {
+                    throw new JsonbException("JsonbTypeInfo key '" + polymorphismTypeInfo.getTypeKey() + "' collides with other properties in json");
                 }
 
                 String bestMatchingAlias = null;
-                for (JsonbSubtype subtype : typeInfo.value()) {
-                    if (subtype.type().isAssignableFrom(clazz)) {
-                        bestMatchingAlias = subtype.alias();
+                for (Map.Entry<String, Class<?>> aliasToType : polymorphismTypeInfo.getAliases().entrySet()) {
+                    String alias = aliasToType.getKey();
+                    Class<?> type = aliasToType.getValue();
 
-                        if (clazz == subtype.type()) { // Exact match found, no need to continue further
+                    if (type.isAssignableFrom(clazz)) {
+                        bestMatchingAlias = alias;
+
+                        if (clazz == type) { // Exact match found, no need to continue further
                             break;
                         }
                     }
                 }
 
                 if (bestMatchingAlias != null) {
-                    result.add(0, Map.entry(typeInfo.key(), bestMatchingAlias));
+                    result.add(0, Map.entry(polymorphismTypeInfo.getTypeKey(), bestMatchingAlias));
                 }
             }
 
-            current = getParentWithTypeInfo(current);
+            polymorphismTypeInfo = polymorphismTypeInfo.getFirstParent();
         }
 
         return result.toArray(Map.Entry[]::new);
     }
 
     public Class<?> getTypeToDeserialize(JsonObject jsonObject, Class<?> clazz) {
-        JsonbPolymorphismTypeInfo typeInfo = typeInfoCache.get(clazz);
+        JsonbPolymorphismTypeInfo typeInfo = getOrCreatePolymorphismTypeInfo(clazz);
         if (typeInfo == null) {
             return clazz;
         }
@@ -101,21 +100,74 @@
         return result;
     }
 
-    public void populateTypeInfoCache(Class<?> clazz) {
+    /**
+     * Looks up a {@link JsonbPolymorphismTypeInfo} from the cache or creates it for the given <code>clazz</code> if it supports polymorphism.
+     * This is the case if either one of these conditions is truthy:
+     * <ul>
+     *     <li><code>clazz</code> has an {@link JsonbTypeInfo} annotation</li>
+     *     <li>any class in the type hierarchy of <code>clazz</code> has an {@link JsonbTypeInfo} annotation</li>
+     * </ul>
+     * @param clazz Class to inspect
+     * @return {@link JsonbPolymorphismTypeInfo} if the class supports polymorphism, <code>null</code> otherwise
+     */
+    public JsonbPolymorphismTypeInfo getOrCreatePolymorphismTypeInfo(Class<?> clazz) {
         if (typeInfoCache.containsKey(clazz)) {
-            return;
+            return typeInfoCache.get(clazz);
         }
 
-        final JsonbTypeInfo annotation = Meta.getAnnotation((AnnotatedElement) clazz, JsonbTypeInfo.class);
-        if (annotation != null) {
-            typeInfoCache.put(clazz, new JsonbPolymorphismTypeInfo(annotation));
+        JsonbPolymorphismTypeInfo result = null;
+        JsonbTypeInfo directAnnotation = Meta.getAnnotation((AnnotatedElement) clazz, JsonbTypeInfo.class);
+        if (directAnnotation != null) {
+            result = new JsonbPolymorphismTypeInfo(clazz, directAnnotation);
         }
+
+        List<JsonbPolymorphismTypeInfo> parents = new ArrayList<>();
+        List<Class<?>> candidates = List.of(clazz);
+        while (!candidates.isEmpty()) {
+            // Parents have been found on previous level -> don't walk inheritance tree further to avoid processing the same classes twice
+            if (!parents.isEmpty()) {
+                break;
+            }
+
+            List<Class<?>> candidatesNextLevel = new ArrayList<>();
+            for (Class<?> current : candidates) {
+                if (current.getSuperclass() != null) {
+                    candidatesNextLevel.add(current.getSuperclass());
+
+                    if (Meta.getAnnotation((AnnotatedElement) current.getSuperclass(), JsonbTypeInfo.class) != null) {
+                        parents.add(getOrCreatePolymorphismTypeInfo(current.getSuperclass()));
+                    }
+                }
+
+                for (Class<?> iface : current.getInterfaces()) {
+                    candidatesNextLevel.add(iface);
+
+                    if (Meta.getAnnotation((AnnotatedElement) iface, JsonbTypeInfo.class) != null) {
+                        parents.add(getOrCreatePolymorphismTypeInfo(iface));
+                    }
+                }
+            }
+
+            candidates = candidatesNextLevel;
+        }
+
+        if (!parents.isEmpty()) {
+            if (result == null) {
+                result = new JsonbPolymorphismTypeInfo(clazz, null);
+            }
+
+            result.getParents().addAll(parents);
+        }
+
+        typeInfoCache.put(clazz, result);
+        return result;
     }
 
     /**
      * Validates {@link JsonbTypeInfo} annotation on clazz and its parents (superclass/interfaces),
      * see {@link JsonbPolymorphismHandler#validateSubtypeCompatibility(Class)}, {@link JsonbPolymorphismHandler#validateOnlyOneParentWithTypeInfo(Class)}
      * and {@link JsonbPolymorphismHandler#validateNoTypeInfoKeyCollision(Class)}
+     *
      * @param classToValidate Class to validate
      * @throws JsonbException validation failed
      */
@@ -132,15 +184,18 @@
      * @throws JsonbException validation failed
      */
     protected void validateSubtypeCompatibility(Class<?> classToValidate) {
-        JsonbTypeInfo typeInfo = Meta.getAnnotation((AnnotatedElement) classToValidate, JsonbTypeInfo.class);
-        if (typeInfo == null) {
+        JsonbPolymorphismTypeInfo polymorphismTypeInfo = getOrCreatePolymorphismTypeInfo(classToValidate);
+        if (polymorphismTypeInfo == null || !polymorphismTypeInfo.hasSubtypeInformation()) {
             return;
         }
 
-        for (JsonbSubtype subtype : typeInfo.value()) {
-            if (!classToValidate.isAssignableFrom(subtype.type())) {
-                throw new JsonbException("JsonbSubtype '" + subtype.alias() + "'" +
-                        " (" + subtype.type().getName() + ") is not a subclass of " + classToValidate);
+        for (Map.Entry<String, Class<?>> aliasToType : polymorphismTypeInfo.getAliases().entrySet()) {
+            String alias = aliasToType.getKey();
+            Class<?> type = aliasToType.getValue();
+
+            if (!classToValidate.isAssignableFrom(type)) {
+                throw new JsonbException("JsonbSubtype '" + alias + "'" +
+                        " (" + type.getName() + ") is not a subclass of " + classToValidate);
             }
         }
     }
@@ -152,17 +207,10 @@
      * @throws JsonbException validation failed
      */
     protected void validateOnlyOneParentWithTypeInfo(Class<?> classToValidate) {
-        boolean found = classToValidate.getSuperclass() != null && Meta.getAnnotation((AnnotatedElement) classToValidate.getSuperclass(), JsonbTypeInfo.class) != null;
-
-        for (Class<?> iface : classToValidate.getInterfaces()) {
-            if (iface != null && Meta.getAnnotation((AnnotatedElement) iface, JsonbTypeInfo.class) != null) {
-                if (found) {
-                    throw new JsonbException("More than one interface/superclass of " + classToValidate.getName() +
-                            " has JsonbTypeInfo Annotation");
-                }
-
-                found = true;
-            }
+        JsonbPolymorphismTypeInfo polymorphismTypeInfo = getOrCreatePolymorphismTypeInfo(classToValidate);
+        if (polymorphismTypeInfo != null && polymorphismTypeInfo.getParents().size() > 1) {
+            throw new JsonbException("More than one interface/superclass of " + classToValidate.getName() +
+                    " has JsonbTypeInfo Annotation");
         }
     }
 
@@ -175,34 +223,15 @@
      */
     protected void validateNoTypeInfoKeyCollision(Class<?> classToValidate) {
         Map<String, Class<?>> keyToDefiningClass = new HashMap<>();
-
-        Class<?> current = classToValidate;
+        JsonbPolymorphismTypeInfo current = getOrCreatePolymorphismTypeInfo(classToValidate);
         while (current != null) {
-            final JsonbTypeInfo annotation = Meta.getAnnotation((AnnotatedElement) current, JsonbTypeInfo.class);
-            if (annotation != null) {
-                String key = annotation.key();
-                final Class<?> existing = keyToDefiningClass.put(key, current);
-                if (existing != null) {
-                    throw new JsonbException("JsonbTypeInfo key '" + key + "' found more than once in type hierarchy of " + classToValidate
-                            + " (first defined in " + existing.getName() + ", then defined again in " + current.getName() + ")");
-                }
+            final Class<?> existing = keyToDefiningClass.put(current.getTypeKey(), current.getClazz());
+            if (existing != null) {
+                throw new JsonbException("JsonbTypeInfo key '" + current.getTypeKey() + "' found more than once in type hierarchy of " + classToValidate
+                        + " (first defined in " + existing.getName() + ", then defined again in " + current.getClazz().getName() + ")");
             }
 
-            current = getParentWithTypeInfo(current);
+            current = current.getFirstParent();
         }
     }
-
-    protected Class<?> getParentWithTypeInfo(Class<?> clazz) {
-        if (clazz.getSuperclass() != null && Meta.getAnnotation((AnnotatedElement) clazz.getSuperclass(), JsonbTypeInfo.class) != null) {
-            return clazz.getSuperclass();
-        }
-
-        for (Class<?> iface : clazz.getInterfaces()) {
-            if (Meta.getAnnotation((AnnotatedElement) iface, JsonbTypeInfo.class) != null) {
-                return iface;
-            }
-        }
-
-        return null;
-    }
 }
diff --git a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTypeInfo.java b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTypeInfo.java
index 15f5c71..d5eafec 100644
--- a/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTypeInfo.java
+++ b/johnzon-jsonb/src/main/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTypeInfo.java
@@ -20,14 +20,30 @@
 
 import jakarta.json.bind.annotation.JsonbSubtype;
 import jakarta.json.bind.annotation.JsonbTypeInfo;
+
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class JsonbPolymorphismTypeInfo {
+    private final List<JsonbPolymorphismTypeInfo> parents;
+    private final Class<?> clazz;
+
     private final String typeKey;
     private final Map<String, Class<?>> aliases;
 
-    protected JsonbPolymorphismTypeInfo(JsonbTypeInfo annotation) {
+    protected JsonbPolymorphismTypeInfo(Class<?> clazz, JsonbTypeInfo annotation) {
+        this.parents = new ArrayList<>();
+        this.clazz = clazz;
+
+        if (annotation == null) {
+            this.typeKey = null;
+            this.aliases = null;
+
+            return;
+        }
+
         this.typeKey = annotation.key();
 
         aliases = new HashMap<>();
@@ -36,6 +52,10 @@
         }
     }
 
+    public boolean hasSubtypeInformation() {
+        return typeKey != null;
+    }
+
     public String getTypeKey() {
         return typeKey;
     }
@@ -43,4 +63,20 @@
     public Map<String, Class<?>> getAliases() {
         return aliases;
     }
+
+    public Class<?> getClazz() {
+        return clazz;
+    }
+
+    public List<JsonbPolymorphismTypeInfo> getParents() {
+        return parents;
+    }
+
+    public JsonbPolymorphismTypeInfo getFirstParent() {
+        if (parents.isEmpty()) {
+            return null;
+        }
+
+        return parents.get(0);
+    }
 }
diff --git a/johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTest.java b/johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTest.java
index 87d8389..7fcc019 100644
--- a/johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTest.java
+++ b/johnzon-jsonb/src/test/java/org/apache/johnzon/jsonb/polymorphism/JsonbPolymorphismTest.java
@@ -42,6 +42,17 @@
     @Rule public JsonbRule jsonb = new JsonbRule();
 
     @Test
+    public void testNestedSerialization() {
+        Labrador labrador = new Labrador();
+        labrador.dogAge = 3;
+        labrador.labradorName = "john";
+        AnimalWrapper wrapper = new AnimalWrapper();
+        wrapper.animal = labrador;
+
+        assertEquals("{\"animal\":{\"@animal\":\"dog\",\"@dog\":\"labrador\",\"dogAge\":3,\"labradorName\":\"john\"}}", jsonb.toJson(wrapper));
+    }
+
+    @Test
     public void testSerialization() {
         Labrador labrador = new Labrador();
         labrador.dogAge = 3;
@@ -100,6 +111,10 @@
 
     }
 
+    public static class AnimalWrapper {
+        public Animal animal;
+    }
+
     @JsonbTypeInfo(key = "@animal", value = @JsonbSubtype(alias = "dog", type = Dog.class))
     public interface Animal {
     }
@@ -136,4 +151,17 @@
             return localDate;
         }
     }
+
+    @Test
+    public void typeInfoNotOnDirectParent() {
+        ConcreteSomething something = new ConcreteSomething();
+        assertEquals("{\"@type\":\"concrete\"}", jsonb.toJson(something));
+    }
+
+    @JsonbTypeInfo(
+            @JsonbSubtype(alias = "concrete", type = ConcreteSomething.class)
+    )
+    public static abstract class AbstractTopLevelSomething { }
+    public static abstract class AbstractMiddleLevelSomething extends AbstractTopLevelSomething { }
+    public static class ConcreteSomething extends AbstractMiddleLevelSomething { }
 }
diff --git a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingGeneratorImpl.java b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingGeneratorImpl.java
index cf44c5c..c06f38d 100644
--- a/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingGeneratorImpl.java
+++ b/johnzon-mapper/src/main/java/org/apache/johnzon/mapper/MappingGeneratorImpl.java
@@ -192,12 +192,6 @@
                     generator.writeStartObject();
                 }
 
-                if (classMapping.serializedPolymorphicProperties != null) {
-                    for (Map.Entry<String, String> polymorphicProperty : classMapping.serializedPolymorphicProperties) {
-                        generator.write(polymorphicProperty.getKey(), polymorphicProperty.getValue());
-                    }
-                }
-
                 final boolean writeEnd = doWriteObjectBody(object, ignoredProperties, jsonPointer, generator);
                 if (writeEnd && writeBody) {
                     generator.writeEnd();
@@ -376,6 +370,12 @@
             return true;
         }
 
+        if (classMapping.serializedPolymorphicProperties != null) {
+            for (Map.Entry<String, String> polymorphicProperty : classMapping.serializedPolymorphicProperties) {
+                generator.write(polymorphicProperty.getKey(), polymorphicProperty.getValue());
+            }
+        }
+
         for (final Map.Entry<String, Mappings.Getter> getterEntry : classMapping.getters.entrySet()) {
             final Mappings.Getter getter = getterEntry.getValue();
             if (ignored != null && ignored.contains(getterEntry.getKey())) {
diff --git a/tck/jsonb/pom.xml b/tck/jsonb/pom.xml
index 880acaf..578adb5 100644
--- a/tck/jsonb/pom.xml
+++ b/tck/jsonb/pom.xml
@@ -21,7 +21,7 @@
   <parent>
     <artifactId>tck</artifactId>
     <groupId>org.apache.johnzon</groupId>
-    <version>2.0.0-SNAPSHOT</version>
+    <version>2.0.1-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/tck/jsonp/pom.xml b/tck/jsonp/pom.xml
index 8b5c048..012b3ce 100644
--- a/tck/jsonp/pom.xml
+++ b/tck/jsonp/pom.xml
@@ -21,7 +21,7 @@
   <parent>
     <artifactId>tck</artifactId>
     <groupId>org.apache.johnzon</groupId>
-    <version>2.0.0-SNAPSHOT</version>
+    <version>2.0.1-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/tck/pom.xml b/tck/pom.xml
index 01aff41..0b253f1 100644
--- a/tck/pom.xml
+++ b/tck/pom.xml
@@ -21,7 +21,7 @@
   <parent>
     <artifactId>johnzon</artifactId>
     <groupId>org.apache.johnzon</groupId>
-    <version>2.0.0-SNAPSHOT</version>
+    <version>2.0.1-SNAPSHOT</version>
   </parent>
   <modelVersion>4.0.0</modelVersion>