diff --git a/src/plugins_types.c b/src/plugins_types.c
index 7445972..62e3498 100644
--- a/src/plugins_types.c
+++ b/src/plugins_types.c
@@ -50,7 +50,7 @@
  * Implementation of the ly_type_free_clb.
  */
 static void
-ly_type_free_canonical(struct ly_ctx *ctx, struct lysc_type *UNUSED(type), struct lyd_value *value)
+ly_type_free_canonical(struct ly_ctx *ctx, struct lyd_value *value)
 {
     lydict_remove(ctx, value->canonized);
     value->canonized = NULL;
@@ -901,12 +901,12 @@
  * Implementation of the ly_type_free_clb.
  */
 static void
-ly_type_free_bits(struct ly_ctx *ctx, struct lysc_type *type, struct lyd_value *value)
+ly_type_free_bits(struct ly_ctx *ctx, struct lyd_value *value)
 {
     LY_ARRAY_FREE(value->bits_items);
     value->bits_items = NULL;
 
-    ly_type_free_canonical(ctx, type, value);
+    ly_type_free_canonical(ctx, value);
 }
 
 
@@ -1347,7 +1347,7 @@
     pred->value = calloc(1, sizeof *pred->value);
 
     type = ((struct lysc_node_leaf*)key)->type;
-    pred->value->plugin = type->plugin;
+    pred->value->realtype = type;
     ret = type->plugin->store(ctx, type, val, val_len, options, ly_type_stored_prefixes_clb, prefixes, format, key, NULL,
                               pred->value, NULL, &err);
     if (ret == LY_EINCOMPLETE) {
@@ -1438,7 +1438,7 @@
             asprintf(&errmsg, "Invalid instance-identifier \"%s\" value - required instance not found.",
                      "TODO");
             /* we have to clean up the storage */
-            type->plugin->free(ctx, type, storage);
+            type->plugin->free(ctx, storage);
 
             goto error;
         }
@@ -1811,12 +1811,12 @@
  * Implementation of the ly_type_free_clb.
  */
 static void
-ly_type_free_instanceid(struct ly_ctx *ctx, struct lysc_type *type, struct lyd_value *value)
+ly_type_free_instanceid(struct ly_ctx *ctx, struct lyd_value *value)
 {
     lyd_value_free_path(ctx, value->target);
     value->target = NULL;
 
-    ly_type_free_canonical(ctx, type, value);
+    ly_type_free_canonical(ctx, value);
 }
 
 /**
@@ -1848,7 +1848,7 @@
         storage_dummy = 1;
     }
     /* rewrite leafref plugin stored in the storage by default */
-    storage->plugin = type_lr->realtype->plugin;
+    storage->realtype = type_lr->realtype;
 
     /* check value according to the real type of the leafref target */
     ret = type_lr->realtype->plugin->store(ctx, type_lr->realtype, value, value_len, options,
@@ -2010,7 +2010,7 @@
                 } while (*token != ']');
 
                 /* compare key and the value */
-                if (key->value.plugin->compare(&key->value, &((struct lyd_node_term*)value)->value)) {
+                if (key->value.realtype->plugin->compare(&key->value, &((struct lyd_node_term*)value)->value)) {
                     /* nodes does not match, try another instance */
 next_instance:
                     token = first_pred;
@@ -2048,7 +2048,7 @@
     }
 
     if (storage_dummy) {
-        storage->plugin->free(ctx, type_lr->realtype, storage);
+        storage->realtype->plugin->free(ctx, storage);
         free(storage);
     }
     return ret;
@@ -2058,7 +2058,7 @@
         *err = ly_err_new(LY_LLERR, LY_EVALID, LYVE_RESTRICTION, errmsg, NULL, NULL);
     }
     if (storage_dummy) {
-        storage->plugin->free(ctx, type_lr->realtype, storage);
+        storage->realtype->plugin->free(ctx, storage);
         free(storage);
     }
     return LY_EVALID;
@@ -2073,7 +2073,7 @@
 static LY_ERR
 ly_type_compare_leafref(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    return val1->plugin->compare(val1, val2);
+    return val1->realtype->plugin->compare(val1, val2);
 }
 
 /**
@@ -2082,11 +2082,9 @@
  * Implementation of the ly_type_free_clb.
  */
 static void
-ly_type_free_leafref(struct ly_ctx *ctx, struct lysc_type *type, struct lyd_value *value)
+ly_type_free_leafref(struct ly_ctx *ctx, struct lyd_value *value)
 {
-    struct lysc_type *realtype = ((struct lysc_type_leafref*)type)->realtype;
-
-    realtype->plugin->free(ctx, realtype, value);
+    value->realtype->plugin->free(ctx, value);
 }
 
 /**
@@ -2113,12 +2111,24 @@
          * about the second call to avoid rewriting the canonized value */
         secondcall = 1;
 
-        /* get u of the used type to call the store callback second time, if it fails
-         * we are continuing with another type in row, anyway now we should have the data */
-        LY_ARRAY_FOR(type_u->types, u) {
-            if (type_u->types[u] == subvalue->type) {
-                goto search_subtype;
-            }
+        /* call the callback second time */
+        ret = subvalue->value->realtype->plugin->store(ctx, subvalue->value->realtype, value, value_len,
+                                                       options & ~(LY_TYPE_OPTS_CANONIZE | LY_TYPE_OPTS_DYNAMIC),
+                                                       ly_type_stored_prefixes_clb, subvalue->prefixes, format,
+                                                       context_node, trees, subvalue->value, NULL, err);
+        if (ret) {
+            /* second call failed, we have to try another subtype of the union.
+             * Unfortunately, since the realtype can change (e.g. in leafref), we are not able to detect
+             * which of the subtype's were tried the last time, so we have to try all of them.
+             * We also have to remove the LY_TYPE_OPTS_SECOND_CALL flag since the callbacks will be now
+             * called for the first time.
+             * In the second call we should have all the data instances, so the LY_EINCOMPLETE should not
+             * happen again.
+             */
+            options = options & ~LY_TYPE_OPTS_SECOND_CALL;
+            ly_err_free(*err);
+            *err = NULL;
+            goto search_subtype;
         }
     } else {
         /* prepare subvalue storage */
@@ -2128,12 +2138,10 @@
         /* store prefixes for later use */
         subvalue->prefixes = ly_type_get_prefixes(ctx, value, value_len, get_prefix, parser);
 
+search_subtype:
         /* use the first usable sybtype to store the value */
         LY_ARRAY_FOR(type_u->types, u) {
-            subvalue->value->plugin = type_u->types[u]->plugin;
-            subvalue->type = type_u->types[u];
-
-search_subtype:
+            subvalue->value->realtype = type_u->types[u];
             ret = type_u->types[u]->plugin->store(ctx, type_u->types[u], value, value_len, options & ~(LY_TYPE_OPTS_CANONIZE | LY_TYPE_OPTS_DYNAMIC),
                                                   ly_type_stored_prefixes_clb, subvalue->prefixes, format,
                                                   context_node, trees, subvalue->value, NULL, err);
@@ -2141,21 +2149,14 @@
                 /* success (or not yet complete) */
                 break;
             }
-
-            if (options & LY_TYPE_OPTS_SECOND_CALL) {
-                /* if started as LY_TYPE_OPTS_SECOND_CALL, we need it just for a single call of the
-                 * store callback, because if it fails, another store callback is called for the first time */
-                options = options & ~LY_TYPE_OPTS_SECOND_CALL;
-            }
-            if (*err) {
-                ly_err_free(*err);
-                *err = NULL;
-            }
+            ly_err_free(*err);
+            *err = NULL;
         }
-    }
-    if (u == LY_ARRAY_SIZE(type_u->types)) {
-        asprintf(&errmsg, "Invalid union value \"%.*s\" - no matching subtype found.", (int)value_len, value);
-        goto error;
+
+        if (u == LY_ARRAY_SIZE(type_u->types)) {
+            asprintf(&errmsg, "Invalid union value \"%.*s\" - no matching subtype found.", (int)value_len, value);
+            goto error;
+        }
     }
     /* success */
 
@@ -2199,7 +2200,7 @@
     free(subvalue->value);
     free(subvalue);
     if ((options & LY_TYPE_OPTS_SECOND_CALL) && (options & LY_TYPE_OPTS_STORE)) {
-        subvalue = NULL;
+        storage->subvalue = NULL;
     }
 
     return LY_EVALID;
@@ -2213,10 +2214,10 @@
 static LY_ERR
 ly_type_compare_union(const struct lyd_value *val1, const struct lyd_value *val2)
 {
-    if (val1->subvalue->type != val2->subvalue->type) {
+    if (val1->realtype != val2->realtype) {
         return LY_EVALID;
     }
-    return val1->subvalue->type->plugin->compare(val1->subvalue->value, val2->subvalue->value);
+    return val1->realtype->plugin->compare(val1->subvalue->value, val2->subvalue->value);
 }
 
 /**
@@ -2225,13 +2226,13 @@
  * Implementation of the ly_type_free_clb.
  */
 static void
-ly_type_free_union(struct ly_ctx *ctx, struct lysc_type *type, struct lyd_value *value)
+ly_type_free_union(struct ly_ctx *ctx, struct lyd_value *value)
 {
     unsigned int u;
 
     if (value->subvalue) {
         if (value->subvalue->value) {
-            value->subvalue->value->plugin->free(ctx, value->subvalue->type, value->subvalue->value);
+            value->subvalue->value->realtype->plugin->free(ctx, value->subvalue->value);
             LY_ARRAY_FOR(value->subvalue->prefixes, u) {
                 lydict_remove(ctx, value->subvalue->prefixes[u].prefix);
             }
@@ -2241,10 +2242,12 @@
         free(value->subvalue);
         value->subvalue = NULL;
     }
-    ly_type_free_canonical(ctx, type, value);
+    ly_type_free_canonical(ctx, value);
 }
 
-
+/**
+ * @brief Set of type plugins for YANG built-in types
+ */
 struct lysc_type_plugin ly_builtin_type_plugins[LY_DATA_TYPE_COUNT] = {
     {0}, /* LY_TYPE_UNKNOWN */
     {.type = LY_TYPE_BINARY, .store = ly_type_store_binary, .compare = ly_type_compare_canonical, .free = ly_type_free_canonical},
@@ -2267,4 +2270,3 @@
     {.type = LY_TYPE_INT32, .store = ly_type_store_int, .compare = ly_type_compare_canonical, .free = ly_type_free_canonical},
     {.type = LY_TYPE_INT64, .store = ly_type_store_int, .compare = ly_type_compare_canonical, .free = ly_type_free_canonical},
 };
-
diff --git a/src/plugins_types.h b/src/plugins_types.h
index 4b13f1f..a4b243f 100644
--- a/src/plugins_types.h
+++ b/src/plugins_types.h
@@ -137,10 +137,9 @@
  * Note that this callback is responsible also for freeing the canonized member in the @p value.
  *
  * @param[in] ctx libyang ctx to enable correct manipulation with values that are in the dictionary.
- * @param[in] type Type of the stored value.
  * @param[in,out] value Value structure to free the data stored there by the plugin's ly_type_store_clb() callback
  */
-typedef void (*ly_type_free_clb)(struct ly_ctx *ctx, struct lysc_type *type, struct lyd_value *value);
+typedef void (*ly_type_free_clb)(struct ly_ctx *ctx, struct lyd_value *value);
 
 /**
  * @brief Hold type-specific functions for various operations with the data values.
diff --git a/src/tree_data.c b/src/tree_data.c
index c9ef10f..19a3549 100644
--- a/src/tree_data.c
+++ b/src/tree_data.c
@@ -163,7 +163,9 @@
     ctx = node->schema->module->ctx;
 
     type = ((struct lysc_node_leaf*)node->schema)->type;
-    node->value.plugin = type->plugin;
+    if (!second) {
+        node->value.realtype = type;
+    }
     rc = type->plugin->store(ctx, type, value, value_len, options, get_prefix, parser, format,
                              trees ? (void*)node : (void*)node->schema, trees,
                              &node->value, NULL, &err);
@@ -286,7 +288,7 @@
     }
 
 cleanup:
-    type->plugin->free(ctx, type, &data);
+    type->plugin->free(ctx, &data);
 
     return ret;
 }
diff --git a/src/tree_data.h b/src/tree_data.h
index 242ffa1..96e0e81 100644
--- a/src/tree_data.h
+++ b/src/tree_data.h
@@ -183,7 +183,6 @@
                 const char *prefix;           /**< prefix string used in the canonized string to identify the mod of the YANG schema */
                 const struct lys_module *mod; /**< YANG schema module identified by the prefix string */
             } *prefixes;                 /**< list of mappings between prefix in canonized value to a YANG schema ([sized array](@ref sizedarrays)) */
-            struct lysc_type *type;
             struct lyd_value *value;
         } *subvalue;
 
@@ -213,10 +212,13 @@
     };  /**< The union is just a list of shorthands to possible values stored by a type's plugin. libyang works only with the canonized string,
              this specific data type storage is just to simplify use of the values by the libyang users. */
 
-    struct lysc_type_plugin *plugin; /**< pointer to the type plugin which stored the data. This pointer can differ from the pointer
-                                          in the lysc_type structure since the plugin itself can use other plugins for storing data.
-                                          Speaking about built-in types, this is the case of leafref which stores data as its target type.
-                                          Similarly union types stores the currently used type plugin in its internal lyd_value structure. */
+    struct lysc_type *realtype; /**< pointer to the real type of the data stored in the value structure. This type can differ from the type
+                                          in the schema node of the data node since the type's store plugin can use other types/plugins for
+                                          storing data. Speaking about built-in types, this is the case of leafref which stores data as its
+                                          target type. In contrast, union type also use its subtype's callbacks, but inside an internal data
+                                          lyd_value::subvalue structure, so here is the pointer to the union type.
+                                          In general, this type is used to get free callback for this lyd_value structure, so it must reflect
+                                          the type used to store data directly in the same lyd_value instance. */
 };
 
 /**
diff --git a/src/tree_data_free.c b/src/tree_data_free.c
index 36a11a0..80653d8 100644
--- a/src/tree_data_free.c
+++ b/src/tree_data_free.c
@@ -33,8 +33,7 @@
     LY_ARRAY_FOR(path, u) {
         LY_ARRAY_FOR(path[u].predicates, v) {
             if (path[u].predicates[v].type > 0) {
-                struct lysc_type *t = ((struct lysc_node_leaf*)path[u].predicates[v].key)->type;
-                t->plugin->free(ctx, t, path[u].predicates[v].value);
+                ((struct lysc_node_leaf*)path[u].predicates[v].key)->type->plugin->free(ctx, path[u].predicates[v].value);
                 free(path[u].predicates[v].value);
             }
         }
@@ -186,8 +185,7 @@
         }
 #endif
     } else if (node->schema->nodetype & LYD_NODE_TERM) {
-        struct lysc_type *type = ((struct lysc_node_leaf*)node->schema)->type;
-        type->plugin->free(ctx, type, &((struct lyd_node_term*)node)->value);
+        ((struct lysc_node_leaf*)node->schema)->type->plugin->free(ctx, &((struct lyd_node_term*)node)->value);
     }
 
     /* free the node's attributes */
diff --git a/tests/features/test_types.c b/tests/features/test_types.c
index 3da18a5..6d057d0 100644
--- a/tests/features/test_types.c
+++ b/tests/features/test_types.c
@@ -1109,7 +1109,8 @@
     leaf = (struct lyd_node_term*)tree;
     assert_string_equal("12", leaf->value.canonized);
     assert_null(leaf->value.subvalue->prefixes);
-    assert_int_equal(LY_TYPE_LEAFREF, leaf->value.subvalue->type->basetype);
+    assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
+    assert_int_equal(LY_TYPE_INT8, leaf->value.subvalue->value->realtype->basetype);
     assert_int_equal(12, leaf->value.subvalue->value->int8);
     lyd_free_all(tree);
 
@@ -1122,7 +1123,8 @@
     leaf = (struct lyd_node_term*)tree;
     assert_string_equal("2", leaf->value.canonized);
     assert_null(leaf->value.subvalue->prefixes);
-    assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->type->basetype);
+    assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
+    assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->value->realtype->basetype);
     lyd_free_all(tree);
 
     data = "<un1 xmlns=\"urn:tests:types\" xmlns:d=\"urn:tests:defs\">d:fast-ethernet</un1>";
@@ -1132,7 +1134,8 @@
     leaf = (struct lyd_node_term*)tree;
     assert_string_equal("d:fast-ethernet", leaf->value.canonized);
     assert_non_null(leaf->value.subvalue->prefixes);
-    assert_int_equal(LY_TYPE_IDENT, leaf->value.subvalue->type->basetype);
+    assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
+    assert_int_equal(LY_TYPE_IDENT, leaf->value.subvalue->value->realtype->basetype);
     assert_string_equal("fast-ethernet", leaf->value.subvalue->value->canonized);
     lyd_free_all(tree);
 
@@ -1143,7 +1146,8 @@
     leaf = (struct lyd_node_term*)tree;
     assert_string_equal("d:superfast-ethernet", leaf->value.canonized);
     assert_non_null(leaf->value.subvalue->prefixes);
-    assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->type->basetype);
+    assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
+    assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->value->realtype->basetype);
     assert_string_equal("d:superfast-ethernet", leaf->value.subvalue->value->canonized);
     lyd_free_all(tree);
 
@@ -1156,7 +1160,8 @@
     leaf = (struct lyd_node_term*)tree;
     assert_string_equal("/a:leaflisttarget[2]", leaf->value.canonized);
     assert_non_null(leaf->value.subvalue->prefixes);
-    assert_int_equal(LY_TYPE_INST, leaf->value.subvalue->type->basetype);
+    assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
+    assert_int_equal(LY_TYPE_INST, leaf->value.subvalue->value->realtype->basetype);
     assert_null(leaf->value.subvalue->value->canonized);
     lyd_free_all(tree);
 
@@ -1169,7 +1174,8 @@
     leaf = (struct lyd_node_term*)tree;
     assert_string_equal("/a:leaflisttarget[3]", leaf->value.canonized);
     assert_non_null(leaf->value.subvalue->prefixes);
-    assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->type->basetype);
+    assert_int_equal(LY_TYPE_UNION, leaf->value.realtype->basetype);
+    assert_int_equal(LY_TYPE_STRING, leaf->value.subvalue->value->realtype->basetype);
     assert_string_equal("/a:leaflisttarget[3]", leaf->value.subvalue->value->canonized);
     lyd_free_all(tree);