diff --git a/cppcache/integration/test/CMakeLists.txt b/cppcache/integration/test/CMakeLists.txt
index 4c583ed..c2d77d3 100644
--- a/cppcache/integration/test/CMakeLists.txt
+++ b/cppcache/integration/test/CMakeLists.txt
@@ -25,6 +25,7 @@
   ExpirationTest.cpp
   FunctionExecutionTest.cpp
   PdxInstanceTest.cpp
+  PdxJsonTypeTest.cpp
   PdxSerializerTest.cpp
   RegionGetAllTest.cpp
   RegionPutAllTest.cpp
diff --git a/cppcache/integration/test/PdxJsonTypeTest.cpp b/cppcache/integration/test/PdxJsonTypeTest.cpp
new file mode 100644
index 0000000..e98eb48
--- /dev/null
+++ b/cppcache/integration/test/PdxJsonTypeTest.cpp
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <framework/Cluster.h>
+#include <framework/Gfsh.h>
+
+#include <future>
+#include <initializer_list>
+#include <iostream>
+#include <memory>
+#include <thread>
+
+#include <gtest/gtest.h>
+
+#include <geode/Cache.hpp>
+#include <geode/PdxInstanceFactory.hpp>
+#include <geode/PoolManager.hpp>
+#include <geode/RegionFactory.hpp>
+#include <geode/RegionShortcut.hpp>
+#include <geode/TypeRegistry.hpp>
+
+#include "CacheRegionHelper.hpp"
+#include "LocalRegion.hpp"
+#include "NestedPdxObject.hpp"
+#include "PdxType.hpp"
+
+namespace {
+using apache::geode::client::Cache;
+using apache::geode::client::CacheableKey;
+using apache::geode::client::CacheableString;
+using apache::geode::client::CacheRegionHelper;
+using apache::geode::client::IllegalStateException;
+using apache::geode::client::LocalRegion;
+using apache::geode::client::PdxFieldTypes;
+using apache::geode::client::PdxInstance;
+using apache::geode::client::PdxInstanceFactory;
+using apache::geode::client::PdxSerializable;
+using apache::geode::client::Region;
+using apache::geode::client::RegionShortcut;
+
+using PdxTests::Address;
+using PdxTests::PdxType;
+
+using testobject::ChildPdx;
+using testobject::ParentPdx;
+
+const std::string gemfireJsonClassName = "__GEMFIRE_JSON";
+
+std::shared_ptr<Region> setupRegion(Cache& cache) {
+  auto region = cache.createRegionFactory(RegionShortcut::PROXY)
+                    .setPoolName("default")
+                    .create("region");
+
+  return region;
+}
+
+TEST(PdxJsonTypeTest, testCreateTwoJsonInstances) {
+  Cluster cluster{LocatorCount{1}, ServerCount{1}};
+  cluster.start();
+  cluster.getGfsh()
+      .create()
+      .region()
+      .withName("region")
+      .withType("REPLICATE")
+      .execute();
+
+  auto cache = cluster.createCache();
+  auto region = setupRegion(cache);
+  auto pdxInstanceFactory =
+      cache.createPdxInstanceFactory(gemfireJsonClassName);
+
+  pdxInstanceFactory.writeString("foo", "bar");
+  auto pdxInstance = pdxInstanceFactory.create();
+
+  region->put("simpleObject", pdxInstance);
+
+  auto retrievedValue = region->get("simpleObject");
+
+  pdxInstance = std::dynamic_pointer_cast<PdxInstance>(retrievedValue);
+
+  EXPECT_FALSE(pdxInstance == nullptr);
+  EXPECT_TRUE(pdxInstance->hasField("foo"));
+  EXPECT_EQ(pdxInstance->getFieldType("foo"), PdxFieldTypes::STRING);
+  EXPECT_EQ(pdxInstance->getStringField("foo"), std::string{"bar"});
+
+  auto pdxInstanceFactory2 =
+      cache.createPdxInstanceFactory(gemfireJsonClassName);
+  pdxInstanceFactory2.writeInt("baz", 42);
+  pdxInstance = pdxInstanceFactory2.create();
+
+  region->put("anotherSimpleObject", pdxInstance);
+  retrievedValue = region->get("anotherSimpleObject");
+
+  pdxInstance = std::dynamic_pointer_cast<PdxInstance>(retrievedValue);
+
+  EXPECT_FALSE(pdxInstance == nullptr);
+  EXPECT_TRUE(pdxInstance->hasField("baz"));
+  EXPECT_EQ(pdxInstance->getFieldType("baz"), PdxFieldTypes::INT);
+  EXPECT_EQ(pdxInstance->getIntField("baz"), 42);
+}
+
+}  // namespace
diff --git a/cppcache/src/PdxType.cpp b/cppcache/src/PdxType.cpp
index 06df022..348acf4 100644
--- a/cppcache/src/PdxType.cpp
+++ b/cppcache/src/PdxType.cpp
@@ -557,7 +557,11 @@
 }
 
 bool PdxType::operator<(const PdxType& other) const {
-  return this->m_className < other.m_className;
+  auto typeIdLessThan = this->m_geodeTypeId < other.m_geodeTypeId;
+  auto typeIdsBothZero =
+      (this->m_geodeTypeId == 0) && (other.m_geodeTypeId == 0);
+  auto classnameLessThan = this->m_className < other.m_className;
+  return (typeIdLessThan || (typeIdsBothZero && classnameLessThan));
 }
 
 }  // namespace client