diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.cpp b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.cpp
index 2a83c809b50..ae9e061e35b 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.cpp
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.cpp
@@ -62,7 +62,6 @@ bool HelloWorldPublisher::init(
         const std::string& topic_name,
         const std::string& server_address,
         unsigned short server_port,
-        unsigned short server_id,
         TransportKind transport)
 {
     hello_.index(0);
@@ -142,7 +141,14 @@ bool HelloWorldPublisher::init(
 
             server_locator.kind = LOCATOR_KIND_TCPv6;
             eprosima::fastdds::rtps::IPLocator::setLogicalPort(server_locator, server_port);
-            eprosima::fastdds::rtps::IPLocator::setIPv6(server_locator, ip_server_address);
+            if (eprosima::fastdds::rtps::IPLocator::isIPv6(ip_server_address))
+            {
+                eprosima::fastdds::rtps::IPLocator::setIPv6(server_locator, ip_server_address);
+            }
+            else
+            {
+                eprosima::fastdds::rtps::IPLocator::setIPv6(server_locator, "::1");
+            }
             break;
         }
 
@@ -154,15 +160,8 @@ bool HelloWorldPublisher::init(
     pqos.wire_protocol().builtin.discovery_config.discoveryProtocol =
             eprosima::fastdds::rtps::DiscoveryProtocol::CLIENT;
 
-    // Set SERVER's GUID prefix
-    RemoteServerAttributes remote_server_att;
-    remote_server_att.guidPrefix = get_discovery_server_guid_from_id(server_id);
-
-    // Set SERVER's listening locator for PDP
-    remote_server_att.metatrafficUnicastLocatorList.push_back(server_locator);
-
     // Add remote SERVER to CLIENT's list of SERVERs
-    pqos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(remote_server_att);
+    pqos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server_locator);
 
     // Add descriptor
     pqos.transport().user_transports.push_back(descriptor);
@@ -179,7 +178,6 @@ bool HelloWorldPublisher::init(
         "Publisher Participant " << pqos.name() <<
         " created with GUID " << participant_->guid() <<
         " connecting to server <" << server_locator  << "> " <<
-        " with Guid: <" << remote_server_att.guidPrefix << "> " <<
         std::endl;
 
     // REGISTER THE TYPE
diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.h b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.h
index a3e9b5e01d8..8397dd5472b 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.h
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerPublisher.h
@@ -46,7 +46,6 @@ class HelloWorldPublisher
             const std::string& topic_name,
             const std::string& server_address,
             unsigned short server_port,
-            unsigned short server_id,
             TransportKind transport);
 
     //! Publish a sample
diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.cpp b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.cpp
index 60a915899fb..e659bd8ad39 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.cpp
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.cpp
@@ -57,12 +57,10 @@ void DiscoveryServer::stop()
 bool DiscoveryServer::init(
         const std::string& server_address,
         unsigned short server_port,
-        unsigned short server_id,
         TransportKind transport,
         bool has_connection_server,
         const std::string& connection_server_address,
-        unsigned short connection_server_port,
-        unsigned short connection_server_id)
+        unsigned short connection_server_port)
 {
     DomainParticipantQos pqos;
     pqos.name("DS-Server");
@@ -163,7 +161,14 @@ bool DiscoveryServer::init(
 
             listening_locator.kind = LOCATOR_KIND_TCPv6;
             eprosima::fastdds::rtps::IPLocator::setLogicalPort(listening_locator, server_port);
-            eprosima::fastdds::rtps::IPLocator::setIPv6(listening_locator, ip_listening_address);
+            if (eprosima::fastdds::rtps::IPLocator::isIPv6(ip_listening_address))
+            {
+                eprosima::fastdds::rtps::IPLocator::setIPv6(listening_locator, ip_listening_address);
+            }
+            else
+            {
+                eprosima::fastdds::rtps::IPLocator::setIPv6(listening_locator, "::1");
+            }
             connection_locator.kind = LOCATOR_KIND_TCPv6;
             eprosima::fastdds::rtps::IPLocator::setIPv6(connection_locator, ip_connection_address);
             eprosima::fastdds::rtps::IPLocator::setLogicalPort(connection_locator, connection_server_port);
@@ -181,9 +186,6 @@ bool DiscoveryServer::init(
     pqos.wire_protocol().builtin.discovery_config.discoveryProtocol =
             eprosima::fastdds::rtps::DiscoveryProtocol::SERVER;
 
-    // Set SERVER's GUID prefix
-    pqos.wire_protocol().prefix = get_discovery_server_guid_from_id(server_id);
-
     // Set SERVER's listening locator for PDP
     pqos.wire_protocol().builtin.metatrafficUnicastLocatorList.push_back(listening_locator);
 
@@ -191,17 +193,10 @@ bool DiscoveryServer::init(
     // Configure Connection address
     ///////////////////////////////
 
-    RemoteServerAttributes remote_server_att;
     if (has_connection_server)
     {
-        // Set SERVER's GUID prefix
-        remote_server_att.guidPrefix = get_discovery_server_guid_from_id(connection_server_id);
-
-        // Set SERVER's listening locator for PDP
-        remote_server_att.metatrafficUnicastLocatorList.push_back(connection_locator);
-
         // Add remote SERVER to CLIENT's list of SERVERs
-        pqos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(remote_server_att);
+        pqos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(connection_locator);
     }
 
 
@@ -224,8 +219,7 @@ bool DiscoveryServer::init(
             "Server Participant " << pqos.name() <<
             " created with GUID " << participant_->guid() <<
             " listening in address <" << listening_locator  << "> " <<
-            " connecting with Discovery Server <" << remote_server_att.guidPrefix << "> "
-            " with address <" << connection_locator  << "> " <<
+            " connecting with Discovery Server <" << connection_locator  << "> " <<
             std::endl;
     }
     else
diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.h b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.h
index 4fd8b6d79f7..0520eb2dc00 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.h
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerServer.h
@@ -44,12 +44,10 @@ class DiscoveryServer
     bool init(
             const std::string& server_address,
             unsigned short server_port,
-            unsigned short server_id,
             TransportKind transport,
             bool has_connection_server,
             const std::string& connection_server_address,
-            unsigned short connection_server_port,
-            unsigned short connection_server_id);
+            unsigned short connection_server_port);
 
     //! Run
     void run(
diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.cpp b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.cpp
index ed0dea34efe..8cfb7f3d194 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.cpp
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.cpp
@@ -67,7 +67,6 @@ bool HelloWorldSubscriber::init(
         uint32_t max_messages,
         const std::string& server_address,
         unsigned short server_port,
-        unsigned short server_id,
         TransportKind transport)
 {
     DomainParticipantQos pqos;
@@ -145,7 +144,14 @@ bool HelloWorldSubscriber::init(
 
             server_locator.kind = LOCATOR_KIND_TCPv6;
             eprosima::fastdds::rtps::IPLocator::setLogicalPort(server_locator, server_port);
-            eprosima::fastdds::rtps::IPLocator::setIPv4(server_locator, ip_server_address);
+            if (eprosima::fastdds::rtps::IPLocator::isIPv6(ip_server_address))
+            {
+                eprosima::fastdds::rtps::IPLocator::setIPv6(server_locator, ip_server_address);
+            }
+            else
+            {
+                eprosima::fastdds::rtps::IPLocator::setIPv6(server_locator, "::1");
+            }
             break;
         }
 
@@ -157,15 +163,8 @@ bool HelloWorldSubscriber::init(
     pqos.wire_protocol().builtin.discovery_config.discoveryProtocol =
             eprosima::fastdds::rtps::DiscoveryProtocol::CLIENT;
 
-    // Set SERVER's GUID prefix
-    RemoteServerAttributes remote_server_att;
-    remote_server_att.guidPrefix = get_discovery_server_guid_from_id(server_id);
-
-    // Set SERVER's listening locator for PDP
-    remote_server_att.metatrafficUnicastLocatorList.push_back(server_locator);
-
     // Add remote SERVER to CLIENT's list of SERVERs
-    pqos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(remote_server_att);
+    pqos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server_locator);
 
     // Add descriptor
     pqos.transport().user_transports.push_back(descriptor);
@@ -183,7 +182,6 @@ bool HelloWorldSubscriber::init(
         "Subscriber Participant " << pqos.name() <<
         " created with GUID " << participant_->guid() <<
         " connecting to server <" << server_locator  << "> " <<
-        " with Guid: <" << remote_server_att.guidPrefix << "> " <<
         std::endl;
 
     // REGISTER THE TYPE
diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.h b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.h
index 2b2c83ceb12..cc81aad5f6a 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.h
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServerSubscriber.h
@@ -49,7 +49,6 @@ class HelloWorldSubscriber
             uint32_t max_messages,
             const std::string& server_address,
             unsigned short server_port,
-            unsigned short server_id,
             TransportKind transport);
 
     //! RUN the subscriber until number samples are received
diff --git a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServer_main.cpp b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServer_main.cpp
index e1badf3b661..e71d6b04fe0 100644
--- a/examples/cpp/dds/DiscoveryServerExample/DiscoveryServer_main.cpp
+++ b/examples/cpp/dds/DiscoveryServerExample/DiscoveryServer_main.cpp
@@ -64,13 +64,11 @@ int main(
     // Discovery Server connection
     std::string connection_address = "127.0.0.1";   // default ip address
     uint16_t connection_port = 16166;   // default physical port
-    uint16_t connection_ds_id = 0;   // default DS id
     bool id_ds_set = false;
 
     // Discovery Server listening
     std::string listening_address = "127.0.0.1";   // default ip address
     uint16_t listening_port = 16166;   // default physical port
-    uint16_t listening_ds_id = 0;   // default DS id
     uint32_t timeout = 0;   // default DS id
 
     if (argc > 1)
@@ -190,16 +188,13 @@ int main(
                 }
 
                 case optionIndex::CONNECTION_PORT:
+                    id_ds_set = true;
                     connection_port = static_cast<uint16_t>(strtol(opt.arg, nullptr, 10));
                     break;
 
                 case optionIndex::CONNECTION_ADDRESS:
-                    connection_address = opt.arg;
-                    break;
-
-                case optionIndex::CONNECTION_DISCOVERY_SERVER_ID:
                     id_ds_set = true;
-                    connection_ds_id = static_cast<uint16_t>(strtol(opt.arg, nullptr, 10));
+                    connection_address = opt.arg;
                     break;
 
                 case optionIndex::LISTENING_PORT:
@@ -221,15 +216,6 @@ int main(
 
                     break;
 
-                case optionIndex::LISTENING_DISCOVERY_SERVER_ID:
-                    if (type != EntityKind::SERVER)
-                    {
-                        print_warning("server", opt.name);
-                        break;
-                    }
-                    listening_ds_id = static_cast<uint16_t>(strtol(opt.arg, nullptr, 10));
-                    break;
-
                 case optionIndex::TIMEOUT:
                     if (type != EntityKind::SERVER)
                     {
@@ -268,15 +254,6 @@ int main(
     //     return 1;
     // }
 
-    // Check that a DS has not same id itself and connection
-    if (id_ds_set && type == EntityKind::SERVER && listening_ds_id == connection_ds_id)
-    {
-        std::cerr << "ERROR: Discovery Servers ids must be different, "
-                  << " cannot connect to a server with same id " << listening_ds_id << std::endl;
-        option::printUsage(fwrite, stdout, usage, columns);
-        return 1;
-    }
-
     // Check that a DS has not same ip and port in listening and connection
     if (id_ds_set &&
             type == EntityKind::SERVER &&
@@ -299,7 +276,6 @@ int main(
                         topic_name,
                         connection_address,
                         connection_port,
-                        connection_ds_id,
                         transport))
             {
                 mypub.run(static_cast<uint32_t>(count), static_cast<uint32_t>(sleep));
@@ -319,7 +295,6 @@ int main(
                         static_cast<uint32_t>(count),
                         connection_address,
                         connection_port,
-                        connection_ds_id,
                         transport))
             {
                 mysub.run(static_cast<uint32_t>(count));
@@ -337,12 +312,10 @@ int main(
             if (myserver.init(
                         listening_address,
                         listening_port,
-                        listening_ds_id,
                         transport,
                         id_ds_set,
                         connection_address,
-                        connection_port,
-                        connection_ds_id))
+                        connection_port))
             {
                 myserver.run(timeout);
             }
diff --git a/examples/cpp/dds/DiscoveryServerExample/README.md b/examples/cpp/dds/DiscoveryServerExample/README.md
index 5d3448e3274..ef236617f4e 100644
--- a/examples/cpp/dds/DiscoveryServerExample/README.md
+++ b/examples/cpp/dds/DiscoveryServerExample/README.md
@@ -35,9 +35,6 @@ Publisher options:
                     Server listening port (Default port: 16166).
                   --transport=<udpv4|udpv6|tcpv4|tcpv6>
                     Use Transport Protocol [udpv4|udpv6|tcpv4|tcpv6] (Default: udpv4).
-  -d <num>        --connection-discovery-server-id <num>
-                    Id of the Discovery Server to connect with. GUID will be
-                    calculated from id (Default: 0).
 
 Subscriber options:
   -t <topic_name> --topic=<topic_name>
@@ -51,16 +48,10 @@ Subscriber options:
                     Server listening port (Default port: 16166).
                   --transport=<udpv4|udpv6|tcpv4|tcpv6>
                     Use Transport Protocol [udpv4|udpv6|tcpv4|tcpv6] (Default: udpv4).
-  -d <num>        --connection-discovery-server-id <num>
-                    Id of the Discovery Server to connect with. GUID will be
-                    calculated from id (Default: 0).
 
 DiscoveryServer options:
                   --listening-address=<IPaddress>
                     Server address (Default address: 127.0.0.1).
-                  --id=<num>
-                    Id of this Discovery Server.
-                    GUID will be calculated from id (Default: 0).
                   --listening-port=<num>
                     Server listening port (Default port: 16166).
                   --transport=<udpv4|udpv6|tcpv4|tcpv6>
@@ -69,10 +60,6 @@ DiscoveryServer options:
                     Server address (Default address: 127.0.0.1).
   -p <num>        --connection-port=<num>
                     Server listening port (Default port: 16166).
-  -d <num>        --connection-discovery-server-id <num>
-                    Id of the Discovery Server to connect with. GUID will be
-                    calculated from id (if not set, this DS will not connect
-                    to other server).
   -z <num>        --timeout <num>
                     Number of seconds before finish the process (Default: 0 = till ^C).
 ```
diff --git a/examples/cpp/dds/DiscoveryServerExample/arg_configuration.h b/examples/cpp/dds/DiscoveryServerExample/arg_configuration.h
index ad01e206847..d7a888df0af 100644
--- a/examples/cpp/dds/DiscoveryServerExample/arg_configuration.h
+++ b/examples/cpp/dds/DiscoveryServerExample/arg_configuration.h
@@ -169,11 +169,9 @@ enum  optionIndex
 
     CONNECTION_ADDRESS,
     CONNECTION_PORT,
-    CONNECTION_DISCOVERY_SERVER_ID,
 
     LISTENING_ADDRESS,
     LISTENING_PORT,
-    LISTENING_DISCOVERY_SERVER_ID,
     TIMEOUT,
 };
 
@@ -239,15 +237,6 @@ const option::Descriptor usage[] = {
         Arg::Transport,
         "  \t--transport <trans> \tUse Transport Protocol [udpv4|udpv6|tcpv4|tcpv6] (UDPv4 by default)."
     },
-    {
-        CONNECTION_DISCOVERY_SERVER_ID,
-        0,
-        "d",
-        "discovery-server-id",
-        Arg::Numeric,
-        "  -d <num>\t--connection-discovery-server-id <num> \tId of the Discovery Server to connect with. "
-        "GUID will be calculated from id (0 by default)."
-    },
 
     /// SUBSCRIBER OPTIONS
     {UNKNOWN_OPT, 0, "", "", Arg::None, "\nSubscriber options:"},
@@ -291,15 +280,6 @@ const option::Descriptor usage[] = {
         Arg::Transport,
         "  \t--transport <trans> \tUse Transport Protocol [udpv4|udpv6|tcpv4|tcpv6] (UDPv4 by default)."
     },
-    {
-        CONNECTION_DISCOVERY_SERVER_ID,
-        0,
-        "d",
-        "discovery-server-id",
-        Arg::Numeric,
-        "  -d <num>\t--connection-discovery-server-id <num> \tId of the Discovery Server to connect with. "
-        "GUID will be calculated from id (0 by default)."
-    },
 
     /// SERVER OPTIONS
     {UNKNOWN_OPT, 0, "", "", Arg::None, "\nDiscovery Server options:"},
@@ -311,14 +291,6 @@ const option::Descriptor usage[] = {
         Arg::String,
         "  \t--listening-address=<IPaddress>  \tServer address (Default address: 127.0.0.1)."
     },
-    {
-        LISTENING_DISCOVERY_SERVER_ID,
-        0,
-        "",
-        "id",
-        Arg::Numeric,
-        "  \t--id <num> \tId of this Discovery Server. GUID will be calculated from id (0 by default)."
-    },
     {
         LISTENING_PORT,
         0,
@@ -351,15 +323,6 @@ const option::Descriptor usage[] = {
         Arg::String,
         "  -c <num> \t--connection-address=<IPaddress>  \tServer address (Default address: 127.0.0.1)."
     },
-    {
-        CONNECTION_DISCOVERY_SERVER_ID,
-        0,
-        "d",
-        "connection-discovery-server-id",
-        Arg::Numeric,
-        "  -d <num>\t--connection-discovery-server-id <num> \tId of the Discovery Server to connect with. "
-        "GUID will be calculated from id (if not set, this DS will not connect to other server)."
-    },
     {
         TIMEOUT,
         0,
diff --git a/examples/cpp/dds/DiscoveryServerExample/common.h b/examples/cpp/dds/DiscoveryServerExample/common.h
index c62356266f0..2012555902d 100644
--- a/examples/cpp/dds/DiscoveryServerExample/common.h
+++ b/examples/cpp/dds/DiscoveryServerExample/common.h
@@ -20,7 +20,7 @@
 #ifndef _EPROSIMA_FASTDDS_EXAMPLES_CPP_DDS_DISCOVERYSERVEREXAMPLE_COMMON_H_
 #define _EPROSIMA_FASTDDS_EXAMPLES_CPP_DDS_DISCOVERYSERVEREXAMPLE_COMMON_H_
 
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
+#include <fastdds/rtps/common/GuidPrefix_t.hpp>
 #include <fastdds/utils/IPLocator.hpp>
 
 enum class TransportKind
@@ -32,19 +32,6 @@ enum class TransportKind
     SHM,
 };
 
-inline eprosima::fastdds::rtps::GuidPrefix_t get_discovery_server_guid_from_id(
-        unsigned short id)
-{
-    eprosima::fastdds::rtps::GuidPrefix_t result;
-
-    // Get default DS guid and modify the one value expected to be changed
-    std::istringstream(eprosima::fastdds::rtps::DEFAULT_ROS2_SERVER_GUIDPREFIX) >> result;
-    result.value[2] =
-            static_cast<eprosima::fastdds::rtps::octet>(id); // This is done like this in Fast
-
-    return result;
-}
-
 inline bool is_ip(
         const std::string ip_str)
 {
diff --git a/include/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp b/include/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp
index 665297f6ed7..f42c560ba80 100644
--- a/include/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp
+++ b/include/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp
@@ -29,7 +29,6 @@
 #include <fastdds/rtps/attributes/PropertyPolicy.hpp>
 #include <fastdds/rtps/attributes/ResourceManagement.hpp>
 #include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
 #include <fastdds/rtps/attributes/ThreadSettings.hpp>
 #include <fastdds/rtps/common/Locator.hpp>
 #include <fastdds/rtps/common/PortParameters.hpp>
@@ -129,6 +128,21 @@ inline std::ostream& operator <<(
     return output;
 }
 
+/**
+ * Returns the guidPrefix associated to the given server id
+ * @param[in] id of the default server whose guidPrefix we want to retrieve
+ * @param[out] guid reference to the guidPrefix to modify
+ * @return true if the server guid can be delivered
+ */
+FASTDDS_EXPORTED_API bool get_server_client_default_guidPrefix(
+        int id,
+        fastdds::rtps::GuidPrefix_t& guid);
+
+// Port used if the ros environment variable doesn't specify one
+constexpr uint16_t DEFAULT_ROS2_SERVER_PORT = 11811;
+// Port used by default for tcp transport
+constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 42100;
+
 //! Filtering flags when discovering participants
 enum ParticipantFilteringFlags : uint32_t
 {
@@ -276,8 +290,8 @@ class DiscoverySettings
      */
     Duration_t discoveryServer_client_syncperiod = { 0, 450 * 1000000}; // 450 milliseconds
 
-    //! Discovery Server settings, only needed if use_CLIENT_DiscoveryProtocol=true
-    eprosima::fastdds::rtps::RemoteServerList_t m_DiscoveryServers;
+    //! Discovery Server initial connections, needed if `discoveryProtocol` = CLIENT | SUPER_CLIENT | SERVER | BACKUP
+    eprosima::fastdds::rtps::LocatorList m_DiscoveryServers;
 
     //! Filtering participants out depending on location
     ParticipantFilteringFlags ignoreParticipantFlags = ParticipantFilteringFlags::NO_FILTER;
diff --git a/include/fastdds/rtps/common/Locator.hpp b/include/fastdds/rtps/common/Locator.hpp
index 88651429434..d688186a572 100644
--- a/include/fastdds/rtps/common/Locator.hpp
+++ b/include/fastdds/rtps/common/Locator.hpp
@@ -452,48 +452,52 @@ inline std::istream& operator >>(
             else
             {
                 kind = LOCATOR_KIND_INVALID;
+                loc.kind = LOCATOR_KIND_INVALID;
             }
 
-            // Get chars :[
-            input >> punct >> punct;
+            if (kind != LOCATOR_KIND_INVALID)
+            {
+                // Get chars :[
+                input >> punct >> punct;
 
-            // Get address in string
-            input.get(sb_address, ']');
-            address = sb_address.str();
+                // Get address in string
+                input.get(sb_address, ']');
+                address = sb_address.str();
 
-            // check if this is a valid IPv4 or IPv6 and call DNS if not
-            if ((kind == LOCATOR_KIND_UDPv4 || kind == LOCATOR_KIND_TCPv4) &&
-                    !IPLocator::isIPv4(address))
-            {
-                auto addresses = IPLocator::resolveNameDNS(address);
-                if (addresses.first.empty())
+                // check if this is a valid IPv4 or IPv6 and call DNS if not
+                if ((kind == LOCATOR_KIND_UDPv4 || kind == LOCATOR_KIND_TCPv4) &&
+                        !IPLocator::isIPv4(address))
                 {
-                    loc.kind = LOCATOR_KIND_INVALID;
-                    EPROSIMA_LOG_WARNING(LOCATOR, "Error deserializing Locator");
-                    return input;
+                    auto addresses = IPLocator::resolveNameDNS(address);
+                    if (addresses.first.empty())
+                    {
+                        loc.kind = LOCATOR_KIND_INVALID;
+                        EPROSIMA_LOG_WARNING(LOCATOR, "Error deserializing Locator");
+                        return input;
+                    }
+                    address = *addresses.first.begin();
                 }
-                address = *addresses.first.begin();
-            }
-            if ((kind == LOCATOR_KIND_UDPv6 || kind == LOCATOR_KIND_TCPv6) &&
-                    !IPLocator::isIPv6(address))
-            {
-                auto addresses = IPLocator::resolveNameDNS(address);
-                if (addresses.second.empty())
+                if ((kind == LOCATOR_KIND_UDPv6 || kind == LOCATOR_KIND_TCPv6) &&
+                        !IPLocator::isIPv6(address))
                 {
-                    loc.kind = LOCATOR_KIND_INVALID;
-                    EPROSIMA_LOG_WARNING(LOCATOR, "Error deserializing Locator");
-                    return input;
+                    auto addresses = IPLocator::resolveNameDNS(address);
+                    if (addresses.second.empty())
+                    {
+                        loc.kind = LOCATOR_KIND_INVALID;
+                        EPROSIMA_LOG_WARNING(LOCATOR, "Error deserializing Locator");
+                        return input;
+                    }
+                    address = *addresses.second.begin();
                 }
-                address = *addresses.second.begin();
-            }
 
-            // Get char ]:
-            input >> punct >> punct;
+                // Get char ]:
+                input >> punct >> punct;
 
-            // Get port
-            input >> port;
+                // Get port
+                input >> port;
 
-            IPLocator::createLocator(kind, address, port, loc);
+                IPLocator::createLocator(kind, address, port, loc);
+            }
         }
         catch (std::ios_base::failure& )
         {
diff --git a/include/fastdds/rtps/common/LocatorList.hpp b/include/fastdds/rtps/common/LocatorList.hpp
index a466f121d59..149eac8e10b 100644
--- a/include/fastdds/rtps/common/LocatorList.hpp
+++ b/include/fastdds/rtps/common/LocatorList.hpp
@@ -166,6 +166,13 @@ class LocatorList
         return false;
     }
 
+    /// Not equal to operator
+    FASTDDS_EXPORTED_API bool operator !=(
+            const LocatorList& locator_list) const
+    {
+        return !(*this == locator_list);
+    }
+
     /**
      * @brief Return an iterator to the beginning.
      *
diff --git a/include/fastdds/rtps/common/LocatorSelectorEntry.hpp b/include/fastdds/rtps/common/LocatorSelectorEntry.hpp
index abe08d666b4..bfcd8e7f415 100644
--- a/include/fastdds/rtps/common/LocatorSelectorEntry.hpp
+++ b/include/fastdds/rtps/common/LocatorSelectorEntry.hpp
@@ -123,6 +123,14 @@ struct LocatorSelectorEntry
         return entry;
     }
 
+    static LocatorSelectorEntry create_fully_selected_entry(
+            const LocatorList_t& unicast_locators)
+    {
+        // Use previous overload with an empty multicast list
+        LocatorList_t empty_list {};
+        return create_fully_selected_entry(unicast_locators, empty_list);
+    }
+
     //! GUID of the remote entity.
     GUID_t remote_guid;
     //! List of unicast locators to send data to the remote entity.
diff --git a/include/fastdds/rtps/common/RemoteLocators.hpp b/include/fastdds/rtps/common/RemoteLocators.hpp
index 8a06a223f9d..526977def89 100644
--- a/include/fastdds/rtps/common/RemoteLocators.hpp
+++ b/include/fastdds/rtps/common/RemoteLocators.hpp
@@ -193,6 +193,7 @@ inline std::istream& operator >>(
             if (letter == 'M')
             {
                 input.get(sb_aux, '[');
+                input >> punct;
 
                 // Read every locator
                 while (punct != ']')
@@ -207,6 +208,7 @@ inline std::istream& operator >>(
 
             if (letter == 'U')
             {
+                input.get(sb_aux, '[');
                 input >> punct;
 
                 // Read every locator
diff --git a/include/fastdds/rtps/participant/RTPSParticipant.hpp b/include/fastdds/rtps/participant/RTPSParticipant.hpp
index 8d37303823a..f797f4c6be5 100644
--- a/include/fastdds/rtps/participant/RTPSParticipant.hpp
+++ b/include/fastdds/rtps/participant/RTPSParticipant.hpp
@@ -27,6 +27,7 @@
 #include <fastdds/dds/subscriber/qos/ReaderQos.hpp>
 #include <fastdds/rtps/attributes/RTPSParticipantAttributes.hpp>
 #include <fastdds/rtps/builtin/data/ContentFilterProperty.hpp>
+#include <fastdds/rtps/builtin/data/ParticipantProxyData.hpp>
 #include <fastdds/rtps/common/Guid.hpp>
 #include <fastdds/statistics/IListeners.hpp>
 #include <fastdds/fastdds_dll.hpp>
diff --git a/include/fastdds/statistics/dds/domain/DomainParticipant.hpp b/include/fastdds/statistics/dds/domain/DomainParticipant.hpp
index c5bdc3a8c75..a416a605802 100644
--- a/include/fastdds/statistics/dds/domain/DomainParticipant.hpp
+++ b/include/fastdds/statistics/dds/domain/DomainParticipant.hpp
@@ -26,6 +26,7 @@
 #include <fastdds/dds/domain/DomainParticipant.hpp>
 #include <fastdds/dds/publisher/qos/DataWriterQos.hpp>
 #include <fastdds/fastdds_dll.hpp>
+#include <fastdds/rtps/builtin/data/ParticipantProxyData.hpp>
 
 namespace eprosima {
 namespace fastdds {
diff --git a/resources/xsd/fastdds_profiles.xsd b/resources/xsd/fastdds_profiles.xsd
index e85067db314..5b4409368ce 100644
--- a/resources/xsd/fastdds_profiles.xsd
+++ b/resources/xsd/fastdds_profiles.xsd
@@ -740,11 +740,7 @@
 
     <!--builtin Discovery Configuration:
         ├ discoveryProtocol         [string] ("SIMPLE", "CLIENT", "SERVER", "BACKUP", "NONE"),
-        ├ discoveryServersList      [0~1],
-        |   └ RemoteServer          [1~*],
-        |      |   ╚ att. prefix    [string] REQ,
-        |      ├ metatrafficUnicastLocatorList   [0~1],
-        |      └ metatrafficMulticastLocatorList [0~1],
+        ├ discoveryServersList      [0~1] [locatorListType],
         ├ ignoreParticipantFlags    [string] ("NO_FILTER", "FILTER_DIFFERENT_HOST", "FILTER_DIFFERENT_PROCESS", "FILTER_SAME_PROCESS", "FILTER_DIFFERENT_PROCESS | FILTER_SAME_PROCESS"),
         ├ EDP                       [string] ("SIMPLE", "STATIC"),
         ├ simpleEDP                 [0~1],
@@ -773,21 +769,7 @@
                         </xs:restriction>
                     </xs:simpleType>
                 </xs:element>
-                <xs:element name="discoveryServersList" minOccurs="0" maxOccurs="1">
-                    <xs:complexType>
-                        <xs:sequence minOccurs="1" maxOccurs="unbounded">
-                            <xs:element name="RemoteServer" minOccurs="1" maxOccurs="unbounded">
-                                <xs:complexType>
-                                    <xs:all>
-                                        <xs:element name="metatrafficUnicastLocatorList" type="locatorListType" minOccurs="0" maxOccurs="1"/>
-                                        <xs:element name="metatrafficMulticastLocatorList" type="locatorListType" minOccurs="0" maxOccurs="1"/>
-                                    </xs:all>
-                                    <xs:attribute name="prefix" type="prefixType" use="required"/>
-                                </xs:complexType>
-                            </xs:element>
-                        </xs:sequence>
-                    </xs:complexType>
-                </xs:element>
+                <xs:element name="discoveryServersList" type="locatorListType" minOccurs="0" maxOccurs="1"/>
                 <xs:element name="ignoreParticipantFlags" minOccurs="0" maxOccurs="1">
                     <xs:simpleType>
                         <xs:restriction base="xs:string">
diff --git a/src/cpp/CMakeLists.txt b/src/cpp/CMakeLists.txt
index 0c00249b669..1747b8f7135 100644
--- a/src/cpp/CMakeLists.txt
+++ b/src/cpp/CMakeLists.txt
@@ -110,6 +110,7 @@ set(${PROJECT_NAME}_source_files
     rtps/attributes/EndpointSecurityAttributes.cpp
     rtps/attributes/PropertyPolicy.cpp
     rtps/attributes/RTPSParticipantAttributes.cpp
+    rtps/attributes/ServerAttributes.cpp
     rtps/attributes/ThreadSettings.cpp
     rtps/attributes/TopicAttributes.cpp
     rtps/builtin/BuiltinProtocols.cpp
@@ -136,7 +137,6 @@ set(${PROJECT_NAME}_source_files
     rtps/builtin/discovery/participant/PDPServer.cpp
     rtps/builtin/discovery/participant/PDPServerListener.cpp
     rtps/builtin/discovery/participant/PDPSimple.cpp
-    rtps/builtin/discovery/participant/ServerAttributes.cpp
     rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
     rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
     rtps/builtin/liveliness/WLP.cpp
diff --git a/src/cpp/fastdds/domain/DomainParticipantImpl.cpp b/src/cpp/fastdds/domain/DomainParticipantImpl.cpp
index e9b72d13718..ade365b2378 100644
--- a/src/cpp/fastdds/domain/DomainParticipantImpl.cpp
+++ b/src/cpp/fastdds/domain/DomainParticipantImpl.cpp
@@ -1788,32 +1788,6 @@ bool DomainParticipantImpl::can_qos_be_updated(
             EPROSIMA_LOG_WARNING(RTPS_QOS_CHECK, "WireProtocolConfigQos cannot be changed after the participant is enabled, "
                     << "with the exception of builtin.discovery_config.m_DiscoveryServers");
         }
-        else
-        {
-            // This means that the only change is in wire_protocol().builtin.discovery_config.m_DiscoveryServers
-            // In that case, we need to ensure that the current list (to) is strictly contained in the incoming
-            // list (from). For that, we check that every server in the current list (to) is also in the incoming one
-            // (from)
-            for (auto existing_server : to.wire_protocol().builtin.discovery_config.m_DiscoveryServers)
-            {
-                bool contained = false;
-                for (auto incoming_server : from.wire_protocol().builtin.discovery_config.m_DiscoveryServers)
-                {
-                    if (existing_server.guidPrefix == incoming_server.guidPrefix)
-                    {
-                        contained = true;
-                        break;
-                    }
-                }
-                if (!contained)
-                {
-                    updatable = false;
-                    EPROSIMA_LOG_WARNING(RTPS_QOS_CHECK,
-                            "Discovery Servers cannot be removed from the list; they can only be added");
-                    break;
-                }
-            }
-        }
     }
     if (!(to.transport() == from.transport()))
     {
diff --git a/src/cpp/rtps/RTPSDomain.cpp b/src/cpp/rtps/RTPSDomain.cpp
index 779d1feacd9..5045af6c214 100644
--- a/src/cpp/rtps/RTPSDomain.cpp
+++ b/src/cpp/rtps/RTPSDomain.cpp
@@ -36,6 +36,7 @@
 #include <fastdds/utils/IPLocator.hpp>
 #include <fastdds/utils/md5.hpp>
 
+#include <rtps/attributes/ServerAttributes.hpp>
 #include <rtps/common/GuidUtils.hpp>
 #include <rtps/network/utils/external_locators.hpp>
 #include <rtps/participant/RTPSParticipantImpl.h>
@@ -55,6 +56,19 @@ namespace rtps {
 
 using BaseReader = fastdds::rtps::BaseReader;
 
+template<typename _Descriptor>
+bool has_user_transport(
+        const RTPSParticipantAttributes& att)
+{
+    const auto& transports = att.userTransports;
+    const auto end_it = transports.end();
+    return end_it != std::find_if(transports.begin(), end_it,
+                   [](const std::shared_ptr<eprosima::fastdds::rtps::TransportDescriptorInterface>& item)
+                   {
+                       return nullptr != dynamic_cast<_Descriptor*>(item.get());
+                   });
+}
+
 static void guid_prefix_create(
         uint32_t ID,
         GuidPrefix_t& guidP)
@@ -210,6 +224,11 @@ RTPSParticipant* RTPSDomainImpl::createParticipant(
     }
     else
     {
+        if (PParam.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::BACKUP)
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT, "Specifying a GUID prefix is mandatory for BACKUP Discovery Servers.");
+            return nullptr;
+        }
         pimpl = new RTPSParticipantImpl(domain_id, PParam, guidP, p, listen);
     }
 
@@ -499,7 +518,7 @@ RTPSParticipant* RTPSDomainImpl::clientServerEnvironmentCreationOverride(
     RTPSParticipantAttributes client_att(att);
 
     // Retrieve the info from the environment variable
-    RemoteServerList_t& server_list = client_att.builtin.discovery_config.m_DiscoveryServers;
+    LocatorList_t& server_list = client_att.builtin.discovery_config.m_DiscoveryServers;
     if (load_environment_server_info(server_list) && server_list.empty())
     {
         // It's not an error, the environment variable may not be set. Any issue with environment
@@ -507,90 +526,37 @@ RTPSParticipant* RTPSDomainImpl::clientServerEnvironmentCreationOverride(
         return nullptr;
     }
 
-    // Check if some server requires the UDPv6, TCPv4 or TCPv6 transport
-    for (auto& server : server_list)
-    {
-        if (server.requires_transport<LOCATOR_KIND_UDPv6>())
-        {
-            // Extend builtin transports with the UDPv6 transport
-            auto descriptor = std::make_shared<fastdds::rtps::UDPv6TransportDescriptor>();
-            descriptor->sendBufferSize = client_att.sendSocketBufferSize;
-            descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
-            client_att.userTransports.push_back(std::move(descriptor));
-            break;
-        }
-        if (server.requires_transport<LOCATOR_KIND_TCPv4>())
-        {
-            // Check if a TCPv4 transport exists. Otherwise create it
-            fastdds::rtps::TCPTransportDescriptor* pT = nullptr;
-            std::shared_ptr<fastdds::rtps::TCPv4TransportDescriptor> p4;
-            bool no_tcpv4 = true;
-
-            for (auto sp : client_att.userTransports)
-            {
-                pT = dynamic_cast<fastdds::rtps::TCPTransportDescriptor*>(sp.get());
-
-                if (pT != nullptr)
-                {
-                    if (!p4)
-                    {
-                        if ((p4 = std::dynamic_pointer_cast<fastdds::rtps::TCPv4TransportDescriptor>(sp)))
-                        {
-                            // TCPv4 transport already exists
-                            no_tcpv4 = false;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (no_tcpv4)
-            {
-                // Extend builtin transports with the TCPv4 transport
-                auto descriptor = std::make_shared<fastdds::rtps::TCPv4TransportDescriptor>();
-                // Add automatic port
-                descriptor->add_listener_port(0);
-                descriptor->sendBufferSize = client_att.sendSocketBufferSize;
-                descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
-                client_att.userTransports.push_back(std::move(descriptor));
-            }
-
-        }
-        if (server.requires_transport<LOCATOR_KIND_TCPv6>())
-        {
-            // Check if a TCPv6 transport exists. Otherwise create it
-            fastdds::rtps::TCPTransportDescriptor* pT = nullptr;
-            std::shared_ptr<fastdds::rtps::TCPv6TransportDescriptor> p6;
-            bool no_tcpv6 = true;
-
-            for (auto sp : client_att.userTransports)
-            {
-                pT = dynamic_cast<fastdds::rtps::TCPTransportDescriptor*>(sp.get());
-
-                if (pT != nullptr)
-                {
-                    if (!p6)
-                    {
-                        // try to find a descriptor matching the listener port setup
-                        if ((p6 = std::dynamic_pointer_cast<fastdds::rtps::TCPv6TransportDescriptor>(sp)))
-                        {
-                            // TCPv6 transport already exists
-                            no_tcpv6 = false;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (no_tcpv6)
-            {
-                // Extend builtin transports with the TCPv6 transport
-                auto descriptor = std::make_shared<fastdds::rtps::TCPv6TransportDescriptor>();
-                // Add automatic port
-                descriptor->add_listener_port(0);
-                descriptor->sendBufferSize = client_att.sendSocketBufferSize;
-                descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
-                client_att.userTransports.push_back(std::move(descriptor));
-            }
-        }
+    // Check if some address requires the UDPv6, TCPv4 or TCPv6 transport
+    if (server_list.has_kind<LOCATOR_KIND_UDPv6>() &&
+            !has_user_transport<fastdds::rtps::UDPv6TransportDescriptor>(client_att))
+    {
+        // Extend builtin transports with the UDPv6 transport
+        auto descriptor = std::make_shared<fastdds::rtps::UDPv6TransportDescriptor>();
+        descriptor->sendBufferSize = client_att.sendSocketBufferSize;
+        descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
+        client_att.userTransports.push_back(std::move(descriptor));
+    }
+    if (server_list.has_kind<LOCATOR_KIND_TCPv4>() &&
+            !has_user_transport<fastdds::rtps::TCPv4TransportDescriptor>(client_att))
+    {
+        // Extend builtin transports with the TCPv4 transport
+        auto descriptor = std::make_shared<fastdds::rtps::TCPv4TransportDescriptor>();
+        // Add automatic port
+        descriptor->add_listener_port(0);
+        descriptor->sendBufferSize = client_att.sendSocketBufferSize;
+        descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
+        client_att.userTransports.push_back(std::move(descriptor));
+    }
+    if (server_list.has_kind<LOCATOR_KIND_TCPv6>() &&
+            !has_user_transport<fastdds::rtps::TCPv6TransportDescriptor>(client_att))
+    {
+        // Extend builtin transports with the TCPv6 transport
+        auto descriptor = std::make_shared<fastdds::rtps::TCPv6TransportDescriptor>();
+        // Add automatic port
+        descriptor->add_listener_port(0);
+        descriptor->sendBufferSize = client_att.sendSocketBufferSize;
+        descriptor->receiveBufferSize = client_att.listenSocketBufferSize;
+        client_att.userTransports.push_back(std::move(descriptor));
     }
 
     EPROSIMA_LOG_INFO(DOMAIN, "Detected auto client-server environment variable."
diff --git a/src/cpp/rtps/attributes/ServerAttributes.cpp b/src/cpp/rtps/attributes/ServerAttributes.cpp
new file mode 100644
index 00000000000..f77ec978c0b
--- /dev/null
+++ b/src/cpp/rtps/attributes/ServerAttributes.cpp
@@ -0,0 +1,460 @@
+// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed 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.
+
+/**
+ * @file ServerAttributes.cpp
+ *
+ */
+
+#include <forward_list>
+
+#include <fastdds/rtps/attributes/RTPSParticipantAttributes.hpp>
+
+#include <rtps/attributes/ServerAttributes.hpp>
+#include <utils/SystemInfo.hpp>
+
+namespace eprosima {
+namespace fastdds {
+namespace rtps {
+
+template<> const char* server_ostream_separators<char>::list_separator = "; ";
+template<> const wchar_t* server_ostream_separators<wchar_t>::list_separator = L"; ";
+
+template<> const char* server_ostream_separators<char>::locator_separator = "|";
+template<> const wchar_t* server_ostream_separators<wchar_t>::locator_separator = L"|";
+
+bool ros_super_client_env()
+{
+    std::string super_client_str;
+    bool super_client = false;
+    std::vector<std::string> true_vec = {"TRUE", "true", "True", "1"};
+    std::vector<std::string> false_vec = {"FALSE", "false", "False", "0"};
+
+    SystemInfo::get_env(ROS_SUPER_CLIENT, super_client_str);
+    if (super_client_str != "")
+    {
+        if (find(true_vec.begin(), true_vec.end(), super_client_str) != true_vec.end())
+        {
+            super_client = true;
+        }
+        else if (find(false_vec.begin(), false_vec.end(), super_client_str) != false_vec.end())
+        {
+            super_client = false;
+        }
+        else
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP,
+                    "Invalid value for ROS_SUPER_CLIENT environment variable : " << super_client_str);
+        }
+    }
+    return super_client;
+}
+
+const std::string& ros_discovery_server_env()
+{
+    static std::string servers;
+    SystemInfo::get_env(DEFAULT_ROS2_MASTER_URI, servers);
+    return servers;
+}
+
+bool load_environment_server_info(
+        LocatorList_t& servers_list)
+{
+    return load_environment_server_info(ros_discovery_server_env(), servers_list);
+}
+
+bool load_environment_server_info(
+        const std::string& list,
+        LocatorList_t& servers_list)
+{
+    servers_list.clear();
+    if (list.empty())
+    {
+        return true;
+    }
+
+    /* Parsing ancillary regex
+     * Addresses should be ; separated. IPLocator functions are used to identify them in the order:
+     * IPv4, IPv6 or try dns resolution.
+     **/
+    const static std::regex ROS2_SERVER_LIST_PATTERN(R"(([^;]*);?)");
+    const static std::regex ROS2_IPV4_ADDRESSPORT_PATTERN(R"(^((?:[0-9]{1,3}\.){3}[0-9]{1,3})?:?(?:(\d+))?$)");
+    const static std::regex ROS2_IPV6_ADDRESSPORT_PATTERN(
+        R"(^\[?((?:[0-9a-fA-F]{0,4}\:){0,7}[0-9a-fA-F]{0,4})?(?:\])?:?(?:(\d+))?$)");
+    // Regex to handle DNS and UDPv4/6 expressions
+    const static std::regex ROS2_DNS_DOMAINPORT_PATTERN(R"(^(UDPv[46]?:\[[\w\.:-]{0,63}\]|[\w\.-]{0,63}):?(?:(\d+))?$)");
+    // Regex to handle TCPv4/6 expressions
+    const static std::regex ROS2_DNS_DOMAINPORT_PATTERN_TCP(
+        R"(^(TCPv[46]?:\[[\w\.:-]{0,63}\]):?(?:(\d+))?$)");
+
+    // Filling port info
+    auto process_port = [](int port, Locator_t& server)
+            {
+                if (port > std::numeric_limits<uint16_t>::max())
+                {
+                    throw std::out_of_range("Too large port passed into the server's list");
+                }
+
+                if (!IPLocator::setPhysicalPort(server, static_cast<uint16_t>(port)))
+                {
+                    std::stringstream ss;
+                    ss << "Wrong port passed into the server's list " << port;
+                    throw std::invalid_argument(ss.str());
+                }
+            };
+
+    // Add new server
+    auto add_server2qos = [](std::forward_list<Locator>&& locators, LocatorList_t& servers_list)
+            {
+                for (auto& server_address : locators)
+                {
+                    servers_list.push_back(std::move(server_address));
+                }
+            };
+
+    try
+    {
+        // Do the parsing and populate the list
+        Locator_t server_locator(LOCATOR_KIND_UDPv4, DEFAULT_ROS2_SERVER_PORT);
+
+        std::sregex_iterator server_it(
+            list.begin(),
+            list.end(),
+            ROS2_SERVER_LIST_PATTERN,
+            std::regex_constants::match_not_null);
+
+        while (server_it != std::sregex_iterator())
+        {
+            // Retrieve the address (IPv4, IPv6 or DNS name)
+            const std::smatch::value_type sm = *++(server_it->cbegin());
+
+            if (sm.matched)
+            {
+                // Now we must parse the inner expression
+                std::smatch mr;
+                std::string locator(sm);
+
+                if (locator.empty())
+                {
+                    // It's intentionally empty to hint us to ignore this server
+                }
+                // Try first with IPv4
+                else if (std::regex_match(locator, mr, ROS2_IPV4_ADDRESSPORT_PATTERN,
+                        std::regex_constants::match_not_null))
+                {
+                    std::smatch::iterator it = mr.cbegin();
+
+                    // Traverse submatches
+                    if (++it != mr.cend())
+                    {
+                        std::string address = it->str();
+                        server_locator.kind = LOCATOR_KIND_UDPv4;
+                        server_locator.set_Invalid_Address();
+
+                        if (!IPLocator::setIPv4(server_locator, address))
+                        {
+                            std::stringstream ss;
+                            ss << "Wrong ipv4 address passed into the server's list " << address;
+                            throw std::invalid_argument(ss.str());
+                        }
+
+                        if (IPLocator::isAny(server_locator))
+                        {
+                            // A server cannot be reach in all interfaces, it's clearly a localhost call
+                            IPLocator::setIPv4(server_locator, "127.0.0.1");
+                        }
+
+                        // Get port if any
+                        int port = DEFAULT_ROS2_SERVER_PORT;
+                        if (++it != mr.cend() && it->matched)
+                        {
+                            port = stoi(it->str());
+                        }
+
+                        process_port(port, server_locator);
+                    }
+
+                    // Add server to the list
+                    add_server2qos(std::forward_list<Locator>{server_locator}, servers_list);
+                }
+                // Try IPv6 next
+                else if (std::regex_match(locator, mr, ROS2_IPV6_ADDRESSPORT_PATTERN,
+                        std::regex_constants::match_not_null))
+                {
+                    std::smatch::iterator it = mr.cbegin();
+
+                    // Traverse submatches
+                    if (++it != mr.cend())
+                    {
+                        std::string address = it->str();
+                        server_locator.kind = LOCATOR_KIND_UDPv6;
+                        server_locator.set_Invalid_Address();
+
+                        if (!IPLocator::setIPv6(server_locator, address))
+                        {
+                            std::stringstream ss;
+                            ss << "Wrong ipv6 address passed into the server's list " << address;
+                            throw std::invalid_argument(ss.str());
+                        }
+
+                        if (IPLocator::isAny(server_locator))
+                        {
+                            // A server cannot be reach in all interfaces, it's clearly a localhost call
+                            IPLocator::setIPv6(server_locator, "::1");
+                        }
+
+                        // Get port if any
+                        int port = DEFAULT_ROS2_SERVER_PORT;
+                        if (++it != mr.cend() && it->matched)
+                        {
+                            port = stoi(it->str());
+                        }
+
+                        process_port(port, server_locator);
+                    }
+
+                    // Add server to the list
+                    add_server2qos(std::forward_list<Locator>{server_locator}, servers_list);
+                }
+                // Try to resolve DNS
+                else if (std::regex_match(locator, mr, ROS2_DNS_DOMAINPORT_PATTERN,
+                        std::regex_constants::match_not_null))
+                {
+                    std::forward_list<Locator> flist;
+
+                    {
+                        std::stringstream new_locator(locator,
+                                std::ios_base::in |
+                                std::ios_base::out |
+                                std::ios_base::ate);
+
+                        // First try the formal notation, add default port if necessary
+                        if (!mr[2].matched)
+                        {
+                            new_locator << ":" << DEFAULT_ROS2_SERVER_PORT;
+                        }
+
+                        new_locator >> server_locator;
+                    }
+
+                    // Otherwise add all resolved locators
+                    switch ( server_locator.kind )
+                    {
+                        case LOCATOR_KIND_UDPv4:
+                        case LOCATOR_KIND_UDPv6:
+                            flist.push_front(server_locator);
+                            break;
+                        case LOCATOR_KIND_INVALID:
+                        {
+                            std::smatch::iterator it = mr.cbegin();
+
+                            // Traverse submatches
+                            if (++it != mr.cend())
+                            {
+                                std::string domain_name = it->str();
+                                std::set<std::string> ipv4, ipv6;
+                                std::tie(ipv4, ipv6) = IPLocator::resolveNameDNS(domain_name);
+
+                                // Get port if any
+                                int port = DEFAULT_ROS2_SERVER_PORT;
+                                if (++it != mr.cend() && it->matched)
+                                {
+                                    port = stoi(it->str());
+                                }
+
+                                for ( const std::string& loc : ipv4 )
+                                {
+                                    server_locator.kind = LOCATOR_KIND_UDPv4;
+                                    server_locator.set_Invalid_Address();
+                                    IPLocator::setIPv4(server_locator, loc);
+
+                                    if (IPLocator::isAny(server_locator))
+                                    {
+                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
+                                        IPLocator::setIPv4(server_locator, "127.0.0.1");
+                                    }
+
+                                    process_port(port, server_locator);
+                                    flist.push_front(server_locator);
+                                }
+
+                                for ( const std::string& loc : ipv6 )
+                                {
+                                    server_locator.kind = LOCATOR_KIND_UDPv6;
+                                    server_locator.set_Invalid_Address();
+                                    IPLocator::setIPv6(server_locator, loc);
+
+                                    if (IPLocator::isAny(server_locator))
+                                    {
+                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
+                                        IPLocator::setIPv6(server_locator, "::1");
+                                    }
+
+                                    process_port(port, server_locator);
+                                    flist.push_front(server_locator);
+                                }
+                            }
+                        }
+                    }
+
+                    if (flist.empty())
+                    {
+                        std::stringstream ss;
+                        ss << "Wrong domain name passed into the server's list " << locator;
+                        throw std::invalid_argument(ss.str());
+                    }
+
+                    // Add server to the list
+                    add_server2qos(std::move(flist), servers_list);
+                }
+                // Try to resolve TCP DNS
+                else if (std::regex_match(locator, mr, ROS2_DNS_DOMAINPORT_PATTERN_TCP,
+                        std::regex_constants::match_not_null))
+                {
+                    std::forward_list<Locator> flist;
+
+                    {
+                        std::stringstream new_locator(locator,
+                                std::ios_base::in |
+                                std::ios_base::out |
+                                std::ios_base::ate);
+
+                        // First try the formal notation, add default port if necessary
+                        if (!mr[2].matched)
+                        {
+                            new_locator << ":" << DEFAULT_TCP_SERVER_PORT;
+                        }
+
+                        new_locator >> server_locator;
+                    }
+
+                    // Otherwise add all resolved locators
+                    switch ( server_locator.kind )
+                    {
+                        case LOCATOR_KIND_TCPv4:
+                        case LOCATOR_KIND_TCPv6:
+                            IPLocator::setLogicalPort(server_locator, IPLocator::getPhysicalPort(server_locator));
+                            flist.push_front(server_locator);
+                            break;
+                        case LOCATOR_KIND_INVALID:
+                        {
+                            std::smatch::iterator it = mr.cbegin();
+
+                            // Traverse submatches
+                            if (++it != mr.cend())
+                            {
+                                std::string domain_name = it->str();
+                                std::set<std::string> ipv4, ipv6;
+                                std::tie(ipv4, ipv6) = IPLocator::resolveNameDNS(domain_name);
+
+                                // Get port if any
+                                int port = DEFAULT_TCP_SERVER_PORT;
+                                if (++it != mr.cend() && it->matched)
+                                {
+                                    port = stoi(it->str());
+                                }
+
+                                for ( const std::string& loc : ipv4 )
+                                {
+                                    server_locator.kind = LOCATOR_KIND_TCPv4;
+                                    server_locator.set_Invalid_Address();
+                                    IPLocator::setIPv4(server_locator, loc);
+
+                                    if (IPLocator::isAny(server_locator))
+                                    {
+                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
+                                        IPLocator::setIPv4(server_locator, "127.0.0.1");
+                                    }
+
+                                    process_port(port, server_locator);
+                                    IPLocator::setLogicalPort(server_locator, static_cast<uint16_t>(port));
+                                    flist.push_front(server_locator);
+                                }
+
+                                for ( const std::string& loc : ipv6 )
+                                {
+                                    server_locator.kind = LOCATOR_KIND_TCPv6;
+                                    server_locator.set_Invalid_Address();
+                                    IPLocator::setIPv6(server_locator, loc);
+
+                                    if (IPLocator::isAny(server_locator))
+                                    {
+                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
+                                        IPLocator::setIPv6(server_locator, "::1");
+                                    }
+
+                                    process_port(port, server_locator);
+                                    IPLocator::setLogicalPort(server_locator, static_cast<uint16_t>(port));
+                                    flist.push_front(server_locator);
+                                }
+                            }
+                        }
+                    }
+
+                    if (flist.empty())
+                    {
+                        std::stringstream ss;
+                        ss << "Wrong domain name passed into the server's list " << locator;
+                        throw std::invalid_argument(ss.str());
+                    }
+
+                    // Add server to the list
+                    add_server2qos(std::move(flist), servers_list);
+                }
+                else
+                {
+                    std::stringstream ss;
+                    ss << "Wrong locator passed into the server's list " << locator;
+                    throw std::invalid_argument(ss.str());
+                }
+            }
+
+            // Advance to the next server if any
+            ++server_it;
+        }
+
+        // Check for server info
+        if (servers_list.empty())
+        {
+            throw std::invalid_argument("No default server locators were provided.");
+        }
+    }
+    catch (std::exception& e)
+    {
+        EPROSIMA_LOG_ERROR(SERVER_CLIENT_DISCOVERY, e.what());
+        servers_list.clear();
+        return false;
+    }
+
+    return true;
+}
+
+GUID_t RemoteServerAttributes::GetParticipant() const
+{
+    return GUID_t(guidPrefix, c_EntityId_RTPSParticipant);
+}
+
+GUID_t RemoteServerAttributes::GetPDPReader() const
+{
+    return GUID_t(guidPrefix, c_EntityId_SPDPReader);
+}
+
+GUID_t RemoteServerAttributes::GetPDPWriter() const
+{
+    return GUID_t(guidPrefix, c_EntityId_SPDPWriter);
+}
+
+} /* namespace rtps */
+} /* namespace fastdds */
+} /* namespace eprosima */
diff --git a/include/fastdds/rtps/attributes/ServerAttributes.hpp b/src/cpp/rtps/attributes/ServerAttributes.hpp
similarity index 68%
rename from include/fastdds/rtps/attributes/ServerAttributes.hpp
rename to src/cpp/rtps/attributes/ServerAttributes.hpp
index fe1b55e321b..569c2f5cc6f 100644
--- a/include/fastdds/rtps/attributes/ServerAttributes.hpp
+++ b/src/cpp/rtps/attributes/ServerAttributes.hpp
@@ -1,4 +1,4 @@
-// Copyright 2019 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -29,9 +29,9 @@
 #include <list>
 
 namespace eprosima {
-
 namespace fastdds {
 namespace rtps {
+
 class ParticipantProxyData;
 
 /**
@@ -43,7 +43,7 @@ class RemoteServerAttributes
 {
 public:
 
-    FASTDDS_EXPORTED_API inline bool operator ==(
+    inline bool operator ==(
             const RemoteServerAttributes& r) const
     {
         return guidPrefix == r.guidPrefix
@@ -51,20 +51,19 @@ class RemoteServerAttributes
                && metatrafficMulticastLocatorList == r.metatrafficMulticastLocatorList;
     }
 
-    FASTDDS_EXPORTED_API void clear()
+    void clear()
     {
         guidPrefix = fastdds::rtps::GuidPrefix_t::unknown();
         metatrafficUnicastLocatorList.clear();
         metatrafficMulticastLocatorList.clear();
-        is_connected = false;
     }
 
-    FASTDDS_EXPORTED_API fastdds::rtps::GUID_t GetParticipant() const;
+    fastdds::rtps::GUID_t GetParticipant() const;
 
-    FASTDDS_EXPORTED_API fastdds::rtps::GUID_t GetPDPReader() const;
-    FASTDDS_EXPORTED_API fastdds::rtps::GUID_t GetPDPWriter() const;
+    fastdds::rtps::GUID_t GetPDPReader() const;
+    fastdds::rtps::GUID_t GetPDPWriter() const;
 
-    FASTDDS_EXPORTED_API inline bool ReadguidPrefix(
+    inline bool ReadguidPrefix(
             const char* pfx)
     {
         return bool(std::istringstream(pfx) >> guidPrefix);
@@ -78,9 +77,6 @@ class RemoteServerAttributes
     //!Guid prefix
     fastdds::rtps::GuidPrefix_t guidPrefix;
 
-    // Whether connection has been established
-    bool is_connected = false;
-
     // Check if there are specific transport locators associated
     // the template parameter is the locator kind (e.g. LOCATOR_KIND_UDPv4)
     template<int kind> bool requires_transport() const
@@ -96,8 +92,8 @@ typedef std::list<RemoteServerAttributes> RemoteServerList_t;
 template<class charT>
 struct server_ostream_separators
 {
-    FASTDDS_EXPORTED_API static const charT* list_separator;
-    FASTDDS_EXPORTED_API static const charT* locator_separator;
+    static const charT* list_separator;
+    static const charT* locator_separator;
 };
 
 #ifndef _MSC_VER
@@ -137,23 +133,15 @@ std::basic_ostream<charT>& operator <<(
     return output;
 }
 
-// port used if the ros environment variable doesn't specify one
-constexpr uint16_t DEFAULT_ROS2_SERVER_PORT = 11811;
-// default server base guidPrefix
+// Default server base guidPrefix
 const char* const DEFAULT_ROS2_SERVER_GUIDPREFIX = "44.53.00.5f.45.50.52.4f.53.49.4d.41";
-// port used by default for tcp transport
-constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 42100;
-
-/* Environment variable to specify a semicolon-separated list of UDPv4 locators (ip:port) that define remote server
- * locators.
- * The position in the list is used as a "server id" to extrapolate the server's GUID prefix.
- * For the variable to take any effect, the following pre-conditions must be met:
- *    1. The server's GUID prefix must be compliant with the schema
- *       "44.53.<server_id_in_hex>.5f.45.50.52.4f.53.49.4d.41", which is the schema followed by the prefixes generated
- *        when creating server using fastdds cli, being DEFAULT_ROS2_SERVER_GUIDPREFIX the prefix for ID=0.
- *    1. The discovery protocol must be either SIMPLE or SERVER.
- *       1. In the case of SIMPLE, the participant is created as a CLIENT instead.
- *       1. In the case of SERVER, the participant is created as a SERVER, using the DEFAULT_ROS2_MASTER_URI list to
+
+/* Environment variable to specify a semicolon-separated list of locators ([transport]ip:port) that define remote server
+ * locators. The [transport] specification is optional. The default transport is UDPv4.
+ * For the variable to take any effect, the following pre-condition must be met:
+ *    - The discovery protocol must be either SIMPLE or SERVER.
+ *       a. In the case of SIMPLE, the participant is created as a CLIENT instead.
+ *       b. In the case of SERVER, the participant is created as a SERVER, using the DEFAULT_ROS2_MASTER_URI list to
  *          expand the list of remote servers.
  */
 const char* const DEFAULT_ROS2_MASTER_URI = "ROS_DISCOVERY_SERVER";
@@ -169,52 +157,40 @@ const char* const ROS_SUPER_CLIENT = "ROS_SUPER_CLIENT";
 
 /**
  * Retrieves a semicolon-separated list of locators from a string, and
- * populates a RemoteServerList_t mapping list position to default guid.
+ * populates a LocatorList_t.
  * @param[in] list servers listening locator list.
- * @param[out] attributes reference to a RemoteServerList_t to populate.
+ * @param[out] servers_list reference to a LocatorList_t to populate.
  * @return true if parsing succeeds, false otherwise (or if the list is empty)
  */
-FASTDDS_EXPORTED_API bool load_environment_server_info(
+bool load_environment_server_info(
         const std::string& list,
-        RemoteServerList_t& attributes);
+        LocatorList& servers_list);
 
 /**
  * Retrieves a semicolon-separated list of locators from DEFAULT_ROS2_MASTER_URI environment variable, and
- * populates a RemoteServerList_t mapping list position to default guid.
+ * populates a LocatorList_t.
  *
  * The environment variable can be read from an environment file (which allows runtime modification of the remote
  * servers list) or directly from the environment.
  * The value contained in the file takes precedence over the environment value (if both are set).
- * This is to avoid conflicts because only new servers can be added to the list (containing thus all the previously
- * known servers).
  *
- * @param[out] attributes reference to a RemoteServerList_t to populate.
+ * @param[out] servers_list reference to a LocatorList_t to populate.
  * @return true if parsing succeeds, false otherwise
  */
-FASTDDS_EXPORTED_API bool load_environment_server_info(
-        RemoteServerList_t& attributes);
+bool load_environment_server_info(
+        LocatorList& servers_list);
 
 /**
  * Get the value of environment variable DEFAULT_ROS2_MASTER_URI
  * @return The value of environment variable DEFAULT_ROS2_MASTER_URI. Empty string if the variable is not defined.
  */
-FASTDDS_EXPORTED_API const std::string& ros_discovery_server_env();
+const std::string& ros_discovery_server_env();
 
 /**
  * Get the value of environment variable ROS_SUPER_CLIENT
  * @return The value of environment variable ROS_SUPER_CLIENT. False if the variable is not defined.
  */
-FASTDDS_EXPORTED_API bool ros_super_client_env();
-
-/**
- * Returns the guidPrefix associated to the given server id
- * @param[in] id of the default server whose guidPrefix we want to retrieve
- * @param[out] guid reference to the guidPrefix to modify
- * @return true if the server guid can be delivered
- */
-FASTDDS_EXPORTED_API bool get_server_client_default_guidPrefix(
-        int id,
-        fastdds::rtps::GuidPrefix_t& guid);
+bool ros_super_client_env();
 
 } // rtps
 } // fastdds
diff --git a/src/cpp/rtps/builtin/BuiltinProtocols.cpp b/src/cpp/rtps/builtin/BuiltinProtocols.cpp
index 289f8951b02..640a7f1e1ba 100644
--- a/src/cpp/rtps/builtin/BuiltinProtocols.cpp
+++ b/src/cpp/rtps/builtin/BuiltinProtocols.cpp
@@ -166,22 +166,20 @@ void BuiltinProtocols::filter_server_remote_locators(
 {
     eprosima::shared_lock<eprosima::shared_mutex> disc_lock(getDiscoveryMutex());
 
-    for (eprosima::fastdds::rtps::RemoteServerAttributes& rs : m_DiscoveryServers)
+    LocatorList_t allowed_locators;
+
+    for (auto loc : m_DiscoveryServers)
     {
-        LocatorList_t allowed_locators;
-        for (Locator_t& loc : rs.metatrafficUnicastLocatorList)
+        if (nf.is_locator_remote_or_allowed(loc))
+        {
+            allowed_locators.push_back(loc);
+        }
+        else
         {
-            if (nf.is_locator_remote_or_allowed(loc))
-            {
-                allowed_locators.push_back(loc);
-            }
-            else
-            {
-                EPROSIMA_LOG_WARNING(RTPS_PDP, "Ignoring remote server locator " << loc << " : not allowed.");
-            }
+            EPROSIMA_LOG_WARNING(RTPS_PDP, "Ignoring remote server locator " << loc << " : not allowed.");
         }
-        rs.metatrafficUnicastLocatorList.swap(allowed_locators);
     }
+    m_DiscoveryServers.swap(allowed_locators);
 }
 
 bool BuiltinProtocols::addLocalWriter(
diff --git a/src/cpp/rtps/builtin/BuiltinProtocols.h b/src/cpp/rtps/builtin/BuiltinProtocols.h
index 8efd402314d..07b79135977 100644
--- a/src/cpp/rtps/builtin/BuiltinProtocols.h
+++ b/src/cpp/rtps/builtin/BuiltinProtocols.h
@@ -123,7 +123,7 @@ class BuiltinProtocols
     //! Initial peers
     LocatorList_t m_initialPeersList;
     //! Known discovery and backup server container
-    std::list<eprosima::fastdds::rtps::RemoteServerAttributes> m_DiscoveryServers;
+    LocatorList_t m_DiscoveryServers;
 
     /**
      * Add a local Writer to the BuiltinProtocols.
diff --git a/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.cpp b/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.cpp
index 84c29edf267..72caa3ed2ba 100644
--- a/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.cpp
+++ b/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.cpp
@@ -37,11 +37,9 @@ namespace rtps {
 namespace ddb {
 
 DiscoveryDataBase::DiscoveryDataBase(
-        fastdds::rtps::GuidPrefix_t server_guid_prefix,
-        std::set<fastdds::rtps::GuidPrefix_t> servers)
+        const fastdds::rtps::GuidPrefix_t& server_guid_prefix)
     : server_guid_prefix_(server_guid_prefix)
-    , server_acked_by_all_(servers.size() == 0)
-    , servers_(servers)
+    , server_acked_by_all_(true)
     , enabled_(true)
     , new_updates_(0)
     , processing_backup_(false)
@@ -65,10 +63,25 @@ DiscoveryDataBase::~DiscoveryDataBase()
 void DiscoveryDataBase::add_server(
         fastdds::rtps::GuidPrefix_t server)
 {
+    std::lock_guard<std::recursive_mutex> guard(mutex_);
     EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Server " << server << " added");
     servers_.insert(server);
 }
 
+void DiscoveryDataBase::remove_server(
+        fastdds::rtps::GuidPrefix_t server)
+{
+    std::lock_guard<std::recursive_mutex> guard(mutex_);
+    if (servers_.erase(server) == 1)
+    {
+        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Removing server " << server);
+    }
+    else
+    {
+        EPROSIMA_LOG_ERROR(DISCOVERY_DATABASE, "Tried to remove " << server << " but it was not found");
+    }
+}
+
 void DiscoveryDataBase::remove_related_alive_from_history_nts(
         fastdds::rtps::WriterHistory* writer_history,
         const fastdds::rtps::GuidPrefix_t& entity_guid_prefix)
@@ -180,7 +193,7 @@ bool DiscoveryDataBase::pdp_is_relevant(
     // Lock(shared mode) mutex locally
     std::lock_guard<std::recursive_mutex> guard(mutex_);
 
-    EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "PDP is " << change.instanceHandle << " relevant to " << reader_guid);
+    EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "PDP " << change.instanceHandle << " is relevant to " << reader_guid);
 
     auto it = participants_.find(change_guid_prefix);
     if (it != participants_.end())
@@ -594,15 +607,59 @@ void DiscoveryDataBase::create_participant_from_change_(
 }
 
 void DiscoveryDataBase::match_new_server_(
-        eprosima::fastdds::rtps::GuidPrefix_t& participant_prefix)
+        eprosima::fastdds::rtps::GuidPrefix_t& participant_prefix,
+        bool is_superclient)
 {
-    // Send Our DATA(p) to the new participant
-    // If this is not done, our data could be skip afterwards because a gap sent in newer DATA(p)s
-    //  so the new participant could never receive out data
+    // Send Our DATA(p) to the new participant.
+    // If this is not done, our data could be skipped afterwards because of a gap sent in newer DATA(p)s,
+    // so the new participant could never receive our data
     auto our_data_it = participants_.find(server_guid_prefix_);
     assert(our_data_it != participants_.end());
     add_pdp_to_send_(our_data_it->second.change());
 
+    if (!is_superclient)
+    {
+        // To obtain a mesh topology with servers, we need to:
+        // - Make all known servers relevant to the new server
+        // - Make the new server relevant to all known servers
+        // - Send DATA(p) of all known servers to the new server
+        // - Send Data(p) of the new server to all other servers
+        for (auto& part : participants_)
+        {
+            if (part.first != server_guid_prefix_ && !part.second.is_client() && !part.second.is_superclient())
+            {
+                if (part.first == participant_prefix)
+                {
+                    std::lock_guard<std::recursive_mutex> guard(mutex_);
+                    bool resend_new_pdp = false;
+                    for (auto& server: servers_)
+                    {
+                        if (server != participant_prefix)
+                        {
+                            // Make all known servers relevant to the new server, but not matched
+                            part.second.add_or_update_ack_participant(server, false);
+                            resend_new_pdp = true;
+                        }
+                    }
+                    if (resend_new_pdp)
+                    {
+                        // Send DATA(p) of the new server to all other servers.
+                        add_pdp_to_send_(part.second.change());
+                    }
+                }
+                else
+                {
+                    // Make the new server relevant to all known servers
+                    part.second.add_or_update_ack_participant(participant_prefix, false);
+                    // Send DATA(p) of all known servers to the new participant
+                    add_pdp_to_send_(part.second.change());
+                }
+            }
+        }
+    }
+    // The resources needed for TCP new connections are created during the matching process when the
+    // DATA(p) is receieved by each server.
+
     // Create virtual endpoints
     create_virtual_endpoints_(participant_prefix);
 }
@@ -669,7 +726,8 @@ bool DiscoveryDataBase::participant_data_has_changed_(
         const DiscoveryParticipantChangeData& new_change_data)
 {
     return !(participant_info.is_local() == new_change_data.is_local() &&
-           participant_info.is_client() == new_change_data.is_client());
+           participant_info.is_client() == new_change_data.is_client() &&
+           participant_info.is_superclient() == new_change_data.is_superclient());
 }
 
 void DiscoveryDataBase::create_new_participant_from_change_(
@@ -699,7 +757,7 @@ void DiscoveryDataBase::create_new_participant_from_change_(
         // If the DATA(p) it's from this server, it is already in history and we do nothing here
         if (change_guid.guidPrefix != server_guid_prefix_)
         {
-            // If the participant is a new participant, mark that not everyone has ACKed this server's DATA(p)
+            // If the participant is a new participant, mark that not everyone has ACKed this server's DATA(p).
             // TODO if the new participant is a server it may be that our DATA(p) is already acked because he is
             //  our server and we have pinged it. But also if we are its server it could be the case that
             //  our DATA(p) is not acked even when it is our server. Solution: see in PDPServer how the change has
@@ -712,7 +770,7 @@ void DiscoveryDataBase::create_new_participant_from_change_(
                 !ret.first->second.is_client() && ret.first->second.is_local())
         {
             // Match new server and create virtual endpoints
-            match_new_server_(change_guid.guidPrefix);
+            match_new_server_(change_guid.guidPrefix, change_data.is_superclient());
         }
     }
     else
@@ -739,7 +797,7 @@ void DiscoveryDataBase::update_participant_from_change_(
         // If it is local and server the only possibility is it was a remote server and it must be converted to local
         if (!change_data.is_client())
         {
-            match_new_server_(change_guid.guidPrefix);
+            match_new_server_(change_guid.guidPrefix, change_data.is_superclient());
         }
 
         // Update the change data
@@ -821,7 +879,7 @@ void DiscoveryDataBase::create_writers_from_change_(
             // The change could be newer and at the same time not being an update.
             // This happens with DATAs coming from servers, since they take their own DATAs in and out frequently,
             // so the sequence number in `write_params` changes.
-            // To account for that, we discard the DATA if the payload is exactly the same as what wee have.
+            // To account for that, we discard the DATA if the payload is exactly the same as what we have.
             if (!(ch->serializedPayload == writer_it->second.change()->serializedPayload))
             {
                 // Update the change related to the writer and return the old change to the pool
@@ -838,11 +896,11 @@ void DiscoveryDataBase::create_writers_from_change_(
                 }
             }
         }
-        // if the cache is not new we have to release it, because it is repeated or outdated
+        // If the cache is not new we have to release it, because it is repeated or outdated
         else
         {
-            // if the change is the same that we already have, we update the ack list. This is because we have
-            //  received the data from two servers, so we have to set that both of them already know this data
+            // If the change is the same that we already have, we update the ack list. This is because we have
+            // received the data from two servers, so we have to set that both of them already know this data
             if (ch->write_params.sample_identity().sequence_number() ==
                     writer_it->second.change()->write_params.sample_identity().sequence_number())
             {
@@ -956,7 +1014,7 @@ void DiscoveryDataBase::create_readers_from_change_(
                 }
             }
         }
-        // if the cache is not new we have to release it, because it is repeated or outdated
+        // If the cache is not new we have to release it, because it is repeated or outdated
         else
         {
             // if the change is the same that we already have, we update the ack list. This is because we have
@@ -1014,7 +1072,7 @@ void DiscoveryDataBase::create_readers_from_change_(
         // we avoid backprogation of the data.
         reader_it->second.add_or_update_ack_participant(ch->writerGUID.guidPrefix, true);
 
-        // if topic is virtual, it must iterate over all readers
+        // If topic is virtual, it must iterate over all readers
         if (topic_name == virtual_topic_)
         {
             for (auto writer_it : writers_)
@@ -1091,11 +1149,12 @@ void DiscoveryDataBase::match_writer_reader_(
     // TODO reduce number of cases. This is more visual, but can be reduce joining them
     if (writer_info.is_virtual())
     {
-        // writer virtual
+        // Writer virtual
 
-        // If reader is virtual do not exchange info
-        // If not, writer needs all the info from this endpoint
-        if (!reader_info.is_virtual())
+        // If reader is virtual OR not local, do not exchange info. Servers do not redirect Data(p) of remote clients.
+        // Otherwise, writer needs all the info from this endpoint
+        if (!reader_info.is_virtual() &&
+                (reader_participant_info.is_local() || writer_participant_info.is_superclient()))
         {
             // Only if they do not have the info yet
             if (!reader_participant_info.is_relevant_participant(writer_guid.guidPrefix))
@@ -1173,9 +1232,10 @@ void DiscoveryDataBase::match_writer_reader_(
     {
         // Writer external
 
-        // if reader is external do not exchange info
-        // if not, reader needs all the info from this endpoint
-        if (reader_participant_info.is_local())
+        // If reader is external OR virtual, do not exchange info. Servers do not redirect Data(p) of remote clients.
+        // Otherwise, reader needs all the info from this endpoint
+        if (reader_participant_info.is_local() &&
+                (!reader_info.is_virtual() || reader_participant_info.is_superclient()))
         {
             // Only if they do not have the info yet
             if (!writer_participant_info.is_relevant_participant(reader_guid.guidPrefix))
@@ -1426,7 +1486,7 @@ bool DiscoveryDataBase::process_dirty_topics()
                             // If the status is 0, add DATA(r) to a `edp_publications_to_send_` (if it's not there).
                             if (add_edp_subscriptions_to_send_(readers_it->second.change()))
                             {
-                                EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind DATA(r) to send: "
+                                EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding DATA(r) to send: "
                                         << readers_it->second.change()->instanceHandle);
                             }
                         }
@@ -1436,7 +1496,7 @@ bool DiscoveryDataBase::process_dirty_topics()
                         // Add DATA(p) of the client with the writer to `pdp_to_send_` (if it's not there).
                         if (add_pdp_to_send_(parts_reader_it->second.change()))
                         {
-                            EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind readers' DATA(p) to send: "
+                            EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding readers' DATA(p) to send: "
                                     << parts_reader_it->second.change()->instanceHandle);
                         }
                         // Set topic as not-clearable.
@@ -1458,7 +1518,7 @@ bool DiscoveryDataBase::process_dirty_topics()
                             // If the status is 0, add DATA(w) to a `edp_subscriptions_to_send_` (if it's not there).
                             if (add_edp_publications_to_send_(writers_it->second.change()))
                             {
-                                EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind DATA(w) to send: "
+                                EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding DATA(w) to send: "
                                         << writers_it->second.change()->instanceHandle);
                             }
                         }
@@ -1468,7 +1528,7 @@ bool DiscoveryDataBase::process_dirty_topics()
                         // Add DATA(p) of the client with the reader to `pdp_to_send_` (if it's not there).
                         if (add_pdp_to_send_(parts_writer_it->second.change()))
                         {
-                            EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind writers' DATA(p) to send: "
+                            EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding writers' DATA(p) to send: "
                                     << parts_writer_it->second.change()->instanceHandle);
                         }
                         // Set topic as not-clearable.
@@ -1631,48 +1691,6 @@ const std::vector<fastdds::rtps::GuidPrefix_t> DiscoveryDataBase::direct_clients
     return direct_clients_and_servers;
 }
 
-bool DiscoveryDataBase::server_acked_by_my_servers()
-{
-    std::lock_guard<std::recursive_mutex> guard(mutex_);
-
-    if (servers_.size() == 0)
-    {
-        return true;
-    }
-
-    // Find the server's participant and check whether all its servers have ACKed the server's DATA(p)
-    auto this_server = participants_.find(server_guid_prefix_);
-    // check it is always there
-
-    assert(this_server != participants_.end());
-
-    for (auto prefix : servers_)
-    {
-        if (!this_server->second.is_matched(prefix))
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-std::vector<fastdds::rtps::GuidPrefix_t> DiscoveryDataBase::ack_pending_servers()
-{
-    std::lock_guard<std::recursive_mutex> guard(mutex_);
-
-    std::vector<fastdds::rtps::GuidPrefix_t> ack_pending_servers;
-    // Find the server's participant and check whether all its servers have ACKed the server's DATA(p)
-    auto this_server = participants_.find(server_guid_prefix_);
-    for (auto prefix : servers_)
-    {
-        if (!this_server->second.is_matched(prefix))
-        {
-            ack_pending_servers.push_back(prefix);
-        }
-    }
-    return ack_pending_servers;
-}
-
 LocatorList DiscoveryDataBase::participant_metatraffic_locators(
         fastdds::rtps::GuidPrefix_t participant_guid_prefix)
 {
@@ -2242,7 +2260,7 @@ std::map<eprosima::fastdds::rtps::GUID_t, DiscoveryEndpointInfo>::iterator Disco
     auto pit = participants_.find(it->first.guidPrefix);
     if (pit == participants_.end())
     {
-        EPROSIMA_LOG_ERROR(DISCOVERY_DATABASE, "Attempting to delete and orphan reader");
+        EPROSIMA_LOG_ERROR(DISCOVERY_DATABASE, "Attempting to delete an orphan reader");
         // Returning error here could lead to an infinite loop
     }
     else
@@ -2318,12 +2336,13 @@ bool DiscoveryDataBase::add_pdp_to_send_(
         eprosima::fastdds::rtps::CacheChange_t* change)
 {
     // Add DATA(p) to send in next iteration if it is not already there
+    std::lock_guard<std::recursive_mutex> guard(mutex_);
     if (std::find(
                 pdp_to_send_.begin(),
                 pdp_to_send_.end(),
                 change) == pdp_to_send_.end())
     {
-        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind DATA(p) to send: "
+        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding DATA(p) to send: "
                 << change->instanceHandle);
         pdp_to_send_.push_back(change);
         return true;
@@ -2331,6 +2350,18 @@ bool DiscoveryDataBase::add_pdp_to_send_(
     return false;
 }
 
+bool DiscoveryDataBase::add_own_pdp_to_send_()
+{
+    if (!backup_in_progress())
+    {
+        auto our_data_it = participants_.find(server_guid_prefix_);
+        assert(our_data_it != participants_.end());
+
+        return add_pdp_to_send_(our_data_it->second.change());
+    }
+    return false;
+}
+
 bool DiscoveryDataBase::add_edp_publications_to_send_(
         eprosima::fastdds::rtps::CacheChange_t* change)
 {
@@ -2340,7 +2371,7 @@ bool DiscoveryDataBase::add_edp_publications_to_send_(
                 edp_publications_to_send_.end(),
                 change) == edp_publications_to_send_.end())
     {
-        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind DATA(w) to send: "
+        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding DATA(w) to send: "
                 << change->instanceHandle);
         edp_publications_to_send_.push_back(change);
         return true;
@@ -2357,7 +2388,7 @@ bool DiscoveryDataBase::add_edp_subscriptions_to_send_(
                 edp_subscriptions_to_send_.end(),
                 change) == edp_subscriptions_to_send_.end())
     {
-        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Addind DATA(r) to send: "
+        EPROSIMA_LOG_INFO(DISCOVERY_DATABASE, "Adding DATA(r) to send: "
                 << change->instanceHandle);
         edp_subscriptions_to_send_.push_back(change);
         return true;
diff --git a/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.hpp b/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.hpp
index 4ff9249dbca..5758c5a8f35 100644
--- a/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.hpp
+++ b/src/cpp/rtps/builtin/discovery/database/DiscoveryDataBase.hpp
@@ -117,8 +117,7 @@ class DiscoveryDataBase
     friend class AckedFunctor;
 
     DiscoveryDataBase(
-            fastdds::rtps::GuidPrefix_t server_guid_prefix,
-            std::set<fastdds::rtps::GuidPrefix_t> servers);
+            const fastdds::rtps::GuidPrefix_t& server_guid_prefix);
 
     ~DiscoveryDataBase();
 
@@ -289,10 +288,6 @@ class DiscoveryDataBase
         server_acked_by_all_.store(s);
     }
 
-    bool server_acked_by_my_servers();
-
-    std::vector<fastdds::rtps::GuidPrefix_t> ack_pending_servers();
-
     ////////////
     // Data structures utils
 
@@ -307,11 +302,11 @@ class DiscoveryDataBase
             std::map<eprosima::fastdds::rtps::InstanceHandle_t, fastdds::rtps::CacheChange_t*>& changes_map);
 
     // This function erase the last backup and all the changes that has arrived since then and create
-    // a new backup that shows the actual state of the database
+    // a new backup that shows the actual state of the database.
     // This way we can simulate the state of the database from a clean state of json backup, or from
     // an state in the middle of an routine execution, and every message that has arrived and has not
     // been process.
-    // By this, we do not lose any change or information in any case
+    // By this, we do not lose any change or information in any case.
     // This function must be called with the incoming datas blocked
     void clean_backup();
 
@@ -321,7 +316,7 @@ class DiscoveryDataBase
         data_queues_mutex_.lock();
     }
 
-    // Unock the incoming of new data to the DDB queue
+    // Unlock the incoming of new data to the DDB queue
     void unlock_incoming_data()
     {
         data_queues_mutex_.unlock();
@@ -339,27 +334,34 @@ class DiscoveryDataBase
         return new_updates_.exchange(0);
     }
 
-    // Check if an participant is stored as local. If the participant does not exist, it returns false
+    // Check if a participant is stored as local. If the participant does not exist, it returns false
     bool is_participant_local(
             const eprosima::fastdds::rtps::GuidPrefix_t& participant_prefix);
 
     //! Add a server to the list of remote servers
     void add_server(
-            fastdds::rtps::GuidPrefix_t server);
+            const fastdds::rtps::GuidPrefix_t server);
+
+    //! Remove a server from the list of remote servers
+    void remove_server(
+            const fastdds::rtps::GuidPrefix_t server);
 
     // Removes all the changes whose original sender was entity_guid_prefix from writer_history
     void remove_related_alive_from_history_nts(
             fastdds::rtps::WriterHistory* writer_history,
             const fastdds::rtps::GuidPrefix_t& entity_guid_prefix);
 
+    // Add own Data(p) in pdp_to_send if not already in it
+    bool add_own_pdp_to_send_();
+
 protected:
 
-    // change a cacheChange by update or new disposal
+    // Change a cacheChange by update or new disposal
     void update_change_and_unmatch_(
             fastdds::rtps::CacheChange_t* new_change,
             ddb::DiscoverySharedInfo& entity);
 
-    // update the acks
+    // Update the acks
     void add_ack_(
             const eprosima::fastdds::rtps::CacheChange_t* change,
             const eprosima::fastdds::rtps::GuidPrefix_t& acked_entity);
@@ -394,7 +396,8 @@ class DiscoveryDataBase
     // Functions related with create_participant_from_change_
 
     void match_new_server_(
-            eprosima::fastdds::rtps::GuidPrefix_t& participant_prefix);
+            eprosima::fastdds::rtps::GuidPrefix_t& participant_prefix,
+            bool is_superclient);
 
     void create_virtual_endpoints_(
             eprosima::fastdds::rtps::GuidPrefix_t& participant_prefix);
@@ -524,7 +527,7 @@ class DiscoveryDataBase
 
     DBQueue<eprosima::fastdds::rtps::ddb::DiscoveryEDPDataQueueInfo> edp_data_queue_;
 
-    //! Covenient per-topic mapping of readers and writers to speed-up queries
+    //! Convenient per-topic mapping of readers and writers to speed-up queries
     std::map<std::string, std::vector<eprosima::fastdds::rtps::GUID_t>> readers_by_topic_;
     std::map<std::string, std::vector<eprosima::fastdds::rtps::GUID_t>> writers_by_topic_;
 
@@ -567,7 +570,7 @@ class DiscoveryDataBase
     //! Is own server DATA(p) acked by all other clients
     std::atomic<bool> server_acked_by_all_;
 
-    //! List of GUID prefixes of the remote servers
+    //! List of GUID prefixes of the connected remote servers
     std::set<fastdds::rtps::GuidPrefix_t> servers_;
 
     // The virtual topic associated with virtual writers and readers
diff --git a/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantChangeData.hpp b/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantChangeData.hpp
index 98face1c986..a1e611eb874 100644
--- a/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantChangeData.hpp
+++ b/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantChangeData.hpp
@@ -51,6 +51,19 @@ class DiscoveryParticipantChangeData
             bool is_local)
         : metatraffic_locators_(metatraffic_locators)
         , is_client_(is_client)
+        , is_superclient_(false)
+        , is_local_(is_local)
+    {
+    }
+
+    DiscoveryParticipantChangeData(
+            RemoteLocatorList metatraffic_locators,
+            bool is_client,
+            bool is_local,
+            bool is_superclient)
+        : metatraffic_locators_(metatraffic_locators)
+        , is_client_(is_client)
+        , is_superclient_(is_superclient)
         , is_local_(is_local)
     {
     }
@@ -60,6 +73,11 @@ class DiscoveryParticipantChangeData
         return is_client_;
     }
 
+    bool is_superclient() const
+    {
+        return is_superclient_;
+    }
+
     bool is_local() const
     {
         return is_local_;
@@ -74,6 +92,7 @@ class DiscoveryParticipantChangeData
             nlohmann::json& j) const
     {
         j["is_client"] = is_client_;
+        j["is_superclient"] = is_superclient_;
         j["is_local"] = is_local_;
         j["metatraffic_locators"] = object_to_string(metatraffic_locators_);
     }
@@ -86,6 +105,9 @@ class DiscoveryParticipantChangeData
     // This variable affects the discovery filter to applied to each entity:
     // false => send all data ; true => send only data that is required to match endpoints
     bool is_client_ = false;
+    // Wether this participant is a SUPER_CLIENT and needs special treatment
+    // when matching remote endpoints
+    bool is_superclient_ = false;
     // Whether this participant (CLIENT OR SERVER) is a client of this server
     bool is_local_ = false;
 };
diff --git a/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantInfo.hpp b/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantInfo.hpp
index c0a6bf60dbb..2b92388e89e 100644
--- a/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantInfo.hpp
+++ b/src/cpp/rtps/builtin/discovery/database/DiscoveryParticipantInfo.hpp
@@ -95,6 +95,11 @@ class DiscoveryParticipantInfo : public DiscoverySharedInfo
         return participant_change_data_.is_client();
     }
 
+    bool is_superclient() const
+    {
+        return participant_change_data_.is_superclient();
+    }
+
     bool is_local() const
     {
         return participant_change_data_.is_local();
diff --git a/src/cpp/rtps/builtin/discovery/endpoint/EDPServerListeners.cpp b/src/cpp/rtps/builtin/discovery/endpoint/EDPServerListeners.cpp
index 68b1f47ddb3..2fdf1ce6966 100644
--- a/src/cpp/rtps/builtin/discovery/endpoint/EDPServerListeners.cpp
+++ b/src/cpp/rtps/builtin/discovery/endpoint/EDPServerListeners.cpp
@@ -125,7 +125,8 @@ std::string EDPServerPUBListener::get_writer_proxy_topic_name(
     }
     else
     {
-        EPROSIMA_LOG_WARNING(RTPS_EDP_LISTENER, "Writer Proxy Data missing for change " << auxGUID);
+        // This is a normal case in server redundancy scenarios
+        EPROSIMA_LOG_INFO(RTPS_EDP_LISTENER, "Writer Proxy Data missing for change " << auxGUID);
     }
     return topic_name;
 }
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDP.cpp b/src/cpp/rtps/builtin/discovery/participant/PDP.cpp
index 971bf9ef3f2..dd2de6e7c1e 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDP.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDP.cpp
@@ -226,6 +226,71 @@ bool PDP::data_matches_with_prefix(
     return ret_val;
 }
 
+std::string PDP::check_participant_type(
+        const fastdds::dds::ParameterPropertyList_t properties)
+{
+    auto participant_type = std::find_if(
+        properties.begin(),
+        properties.end(),
+        [](const fastdds::dds::ParameterProperty_t& property)
+        {
+            return property.first() == fastdds::dds::parameter_property_participant_type;
+        });
+
+    if (participant_type != properties.end())
+    {
+        if (participant_type->second() == fastdds::rtps::ParticipantType::SERVER)
+        {
+            return fastdds::rtps::ParticipantType::SERVER;
+        }
+        else if (participant_type->second() == fastdds::rtps::ParticipantType::BACKUP)
+        {
+            return fastdds::rtps::ParticipantType::BACKUP;
+        }
+        else if (participant_type->second() == fastdds::rtps::ParticipantType::SIMPLE)
+        {
+            return fastdds::rtps::ParticipantType::SIMPLE;
+        }
+        else if (participant_type->second() == fastdds::rtps::ParticipantType::CLIENT)
+        {
+            return fastdds::rtps::ParticipantType::CLIENT;
+        }
+        else if (participant_type->second() == fastdds::rtps::ParticipantType::SUPER_CLIENT)
+        {
+            return fastdds::rtps::ParticipantType::SUPER_CLIENT;
+        }
+        else
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP_LISTENER, "Wrong " << fastdds::dds::parameter_property_participant_type << ": "
+                                                           << participant_type->second());
+            return fastdds::rtps::ParticipantType::UNKNOWN;
+        }
+    }
+    else
+    {
+        EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, fastdds::dds::parameter_property_participant_type << " is not set");
+        // Fallback to checking whether participant is a SERVER looking for the persistence GUID
+        auto persistence_guid = std::find_if(
+            properties.begin(),
+            properties.end(),
+            [](const fastdds::dds::ParameterProperty_t& property)
+            {
+                return property.first() == fastdds::dds::parameter_property_persistence_guid;
+            });
+        // The presence of persistence GUID property suggests a SERVER. This assumption is made to keep
+        // backwards compatibility with Discovery Server v1.0. However, any participant that has been configured
+        // as persistent will have this property.
+        if (persistence_guid != properties.end())
+        {
+            return fastdds::rtps::ParticipantType::SERVER;
+        }
+        else
+        {
+            return fastdds::rtps::ParticipantType::CLIENT;
+        }
+    }
+}
+
 void PDP::initializeParticipantProxyData(
         ParticipantProxyData* participant_data)
 {
@@ -1370,7 +1435,7 @@ ParticipantProxyData* PDP::get_participant_proxy_data(
     return nullptr;
 }
 
-std::list<eprosima::fastdds::rtps::RemoteServerAttributes>& PDP::remote_server_attributes()
+fastdds::rtps::LocatorList& PDP::remote_server_locators()
 {
     return mp_builtin->m_DiscoveryServers;
 }
@@ -1406,6 +1471,7 @@ void PDP::check_remote_participant_liveliness(
 
 void PDP::set_next_announcement_interval()
 {
+    std::lock_guard<std::recursive_mutex> guardPDP(*this->mp_mutex);
     if (initial_announcements_.count > 0)
     {
         --initial_announcements_.count;
@@ -1428,6 +1494,19 @@ void PDP::set_initial_announcement_interval()
     set_next_announcement_interval();
 }
 
+void PDP::resend_ininitial_announcements()
+{
+    if (enabled_)
+    {
+        {
+            std::lock_guard<std::recursive_mutex> guardPDP(*mp_mutex);
+            initial_announcements_ = m_discovery.discovery_config.initial_announcements;
+        }
+        set_next_announcement_interval();
+        resetParticipantAnnouncement();
+    }
+}
+
 void PDP::set_external_participant_properties_(
         ParticipantProxyData* participant_data)
 {
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDP.h b/src/cpp/rtps/builtin/discovery/participant/PDP.h
index ed95dedfe42..359c6aa8203 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDP.h
+++ b/src/cpp/rtps/builtin/discovery/participant/PDP.h
@@ -432,10 +432,10 @@ class PDP : public fastdds::statistics::rtps::IProxyQueryable
             const GuidPrefix_t& guid_prefix);
 
     /**
-     * Get the list of remote servers to which the client should connect
-     * @return A reference to the list of RemoteServerAttributes
+     * Get the list of remote servers' locators to which the participant should connect
+     * @return A reference to the LocatorList
      */
-    std::list<eprosima::fastdds::rtps::RemoteServerAttributes>& remote_server_attributes();
+    fastdds::rtps::LocatorList& remote_server_locators();
 
     /**
      * Access the temporary proxy pool for reader proxies
@@ -572,6 +572,16 @@ class PDP : public fastdds::statistics::rtps::IProxyQueryable
             const GuidPrefix_t& guid_prefix,
             const ParticipantProxyData& participant_data);
 
+    /**
+     * Obtains the participant type based on a Parameters Properties list.
+     *
+     * @param properties Parameter Properties list to check
+     *
+     * @return a string indicating the participant type.
+     */
+    std::string check_participant_type(
+            const fastdds::dds::ParameterPropertyList_t properties);
+
     /**
      * Gets the key of a participant proxy data.
      *
@@ -606,6 +616,11 @@ class PDP : public fastdds::statistics::rtps::IProxyQueryable
             ParticipantProxyData* pdata,
             bool& should_be_ignored);
 
+    /**
+     * Restores the `initial_announcements_` configuration to resend the initial announcements again.
+     */
+    void resend_ininitial_announcements();
+
 #ifdef FASTDDS_STATISTICS
 
     std::atomic<const fastdds::statistics::rtps::IProxyObserver*> proxy_observer_;
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPClient.cpp b/src/cpp/rtps/builtin/discovery/participant/PDPClient.cpp
index 90e10d43fe7..6e47f3cdb82 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPClient.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPClient.cpp
@@ -49,6 +49,7 @@
 #include <rtps/writer/ReaderProxy.hpp>
 #include <rtps/writer/StatefulWriter.hpp>
 #include <utils/shared_mutex.hpp>
+#include <rtps/common/GuidUtils.hpp>
 #include <utils/SystemInfo.hpp>
 #include <utils/TimeConversion.hpp>
 
@@ -188,17 +189,10 @@ ParticipantProxyData* PDPClient::createParticipantProxyData(
 
     // Verify if this participant is a server
     bool is_server = false;
-
+    std::string part_type = check_participant_type(participant_data.m_properties);
+    if (part_type == ParticipantType::SERVER || part_type == ParticipantType::BACKUP)
     {
-        eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
-
-        for (auto& svr : mp_builtin->m_DiscoveryServers)
-        {
-            if (data_matches_with_prefix(svr.guidPrefix, participant_data))
-            {
-                is_server = true;
-            }
-        }
+        is_server = true;
     }
 
     ParticipantProxyData* pdata = add_participant_proxy_data(participant_data.m_guid, is_server, &participant_data);
@@ -274,7 +268,7 @@ bool PDPClient::create_ds_pdp_best_effort_reader(
     ratt.endpoint.ignore_non_matching_locators = pattr.ignore_non_matching_locators;
     ratt.endpoint.topicKind = WITH_KEY;
 
-    // change depending of backup mode
+    // Change depending on backup mode
     ratt.endpoint.durabilityKind = VOLATILE;
     ratt.endpoint.reliabilityKind = BEST_EFFORT;
 
@@ -440,34 +434,18 @@ bool PDPClient::create_ds_pdp_reliable_endpoints(
         return false;
     }
 
-    // Perform matching with remote servers and ensure output channels are open in the transport for the corresponding
-    // locators
+    // Ensure output channels are open in the transport for the corresponding locators
     {
         eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-        for (const eprosima::fastdds::rtps::RemoteServerAttributes& it : mp_builtin->m_DiscoveryServers)
-        {
-            auto entry = LocatorSelectorEntry::create_fully_selected_entry(
-                it.metatrafficUnicastLocatorList, it.metatrafficMulticastLocatorList);
-            mp_RTPSParticipant->createSenderResources(entry);
+        auto entry = LocatorSelectorEntry::create_fully_selected_entry(
+            mp_builtin->m_DiscoveryServers);
+        mp_RTPSParticipant->createSenderResources(entry);
 
-#if HAVE_SECURITY
-            if (!mp_RTPSParticipant->is_secure())
-            {
-                match_pdp_writer_nts_(it);
-                match_pdp_reader_nts_(it);
-            }
-            else if (!is_discovery_protected)
-            {
-                BaseReader::downcast(endpoints.reader.reader_)->allow_unknown_writers();
-            }
-#else
-            if (!is_discovery_protected)
-            {
-                match_pdp_writer_nts_(it);
-                match_pdp_reader_nts_(it);
-            }
-#endif // HAVE_SECURITY
+        // If SECURITY is disabled, this condition is ALWAYS true
+        if (!is_discovery_protected)
+        {
+            BaseReader::downcast(endpoints.reader.reader_)->allow_unknown_writers();
         }
     }
 
@@ -485,12 +463,30 @@ void PDPClient::assignRemoteEndpoints(
         {
             eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-            // Verify if this participant is a server
-            for (auto& svr : mp_builtin->m_DiscoveryServers)
+            std::string part_type = check_participant_type(pdata->m_properties);
+            if (part_type == ParticipantType::SERVER || part_type == ParticipantType::BACKUP)
             {
-                if (data_matches_with_prefix(svr.guidPrefix, *pdata))
+                // Add new servers to the connected list
+                EPROSIMA_LOG_INFO(RTPS_PDP_CLIENT, "Server [" << pdata->m_guid.guidPrefix << "] matched.");
+                RemoteServerAttributes server;
+                server.guidPrefix = pdata->m_guid.guidPrefix;
+                for (const Locator_t& locator : pdata->metatraffic_locators.multicast)
+                {
+                    server.metatrafficMulticastLocatorList.push_back(locator);
+                }
+                for (const Locator_t& locator : pdata->metatraffic_locators.unicast)
+                {
+                    server.metatrafficUnicastLocatorList.push_back(locator);
+                }
+                connected_servers_.push_back(server);
+
+                // Match incoming server
+#if HAVE_SECURITY
+                if (!should_protect_discovery())
+#endif // HAVE_SECURITY
                 {
-                    svr.is_connected = true;
+                    match_pdp_writer_nts_(server);
+                    match_pdp_reader_nts_(server);
                 }
             }
         }
@@ -502,6 +498,10 @@ void PDPClient::assignRemoteEndpoints(
             perform_builtin_endpoints_matching(*pdata);
         }
     }
+    else
+    {
+        EPROSIMA_LOG_INFO(RTPS_PDP, "Ignoring new participant " << pdata->m_guid);
+    }
 }
 
 void PDPClient::notifyAboveRemoteEndpoints(
@@ -513,22 +513,25 @@ void PDPClient::notifyAboveRemoteEndpoints(
     {
         eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-        // Verify if this participant is a server
-        for (auto& svr : mp_builtin->m_DiscoveryServers)
+        std::string part_type = check_participant_type(pdata.m_properties);
+        if (part_type == ParticipantType::SERVER || part_type == ParticipantType::BACKUP)
         {
-            if (data_matches_with_prefix(svr.guidPrefix, pdata))
+            // Add new servers to the connected list
+            EPROSIMA_LOG_INFO(RTPS_PDP_CLIENT, "Secure Server [" << pdata.m_guid.guidPrefix << "] matched.");
+            RemoteServerAttributes server;
+            server.guidPrefix = pdata.m_guid.guidPrefix;
+            for (const Locator_t& locator : pdata.metatraffic_locators.multicast)
             {
-                if (!svr.is_connected && nullptr != get_participant_proxy_data(svr.guidPrefix))
-                {
-                    //! mark proxy as connected from an unmangled prefix in case
-                    //! it could not be done in assignRemoteEndpoints()
-                    svr.is_connected = true;
-                }
-
-                match_pdp_reader_nts_(svr, pdata.m_guid.guidPrefix);
-                match_pdp_writer_nts_(svr, pdata.m_guid.guidPrefix);
-                break;
+                server.metatrafficMulticastLocatorList.push_back(locator);
             }
+            for (const Locator_t& locator : pdata.metatraffic_locators.unicast)
+            {
+                server.metatrafficUnicastLocatorList.push_back(locator);
+            }
+
+            // Match incoming server
+            match_pdp_writer_nts_(server);
+            match_pdp_reader_nts_(server);
         }
     }
 #endif // HAVE_SECURITY
@@ -594,12 +597,12 @@ void PDPClient::removeRemoteEndpoints(
         eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
         // Verify if this participant is a server
-        for (auto& svr : mp_builtin->m_DiscoveryServers)
+        for (auto it = connected_servers_.begin(); it != connected_servers_.end(); ++it)
         {
-            if (svr.guidPrefix == pdata->m_guid.guidPrefix)
+            if (it->guidPrefix == pdata->m_guid.guidPrefix)
             {
                 std::unique_lock<std::recursive_mutex> lock(*getMutex());
-                svr.is_connected = false;
+                it = connected_servers_.erase(it);
                 is_server = true;
                 mp_sync->restart_timer(); // enable announcement and sync mechanism till this server reappears
             }
@@ -627,7 +630,7 @@ void PDPClient::removeRemoteEndpoints(
             if (!should_protect_discovery())
 #endif // HAVE_SECURITY
             {
-                // rematch but discarding any previous state of the server
+                // Rematch but discarding any previous state of the server
                 // because we know the server shutdown intentionally
                 auto temp_writer_data = get_temporary_writer_proxies_pool().get();
 
@@ -674,10 +677,10 @@ bool PDPClient::all_servers_acknowledge_PDP()
 {
     auto endpoints = static_cast<fastdds::rtps::DiscoveryServerPDPEndpoints*>(builtin_endpoints_.get());
 
-    // check if already initialized
+    // Check if already initialized
     assert(endpoints->writer.history_ && endpoints->writer.writer_);
 
-    // get a reference to client proxy data
+    // Get a reference to client proxy data
     CacheChange_t* pPD;
     if (endpoints->writer.history_->get_min_change(&pPD))
     {
@@ -734,9 +737,9 @@ void PDPClient::announceParticipantState(
         // Add the write params to the sample
         if (dispose)
         {
-            // we must assure when the server is dying that all client are send at least a DATA(p)
-            // note here we can no longer receive and DATA or ACKNACK from clients.
-            // In order to avoid that we send the message directly as in the standard stateless PDP
+            // When the server is dying we must ensure that every client is sent at least a DATA(p).
+            // Note here we can no longer receive and DATA or ACKNACK from clients.
+            // In order to avoid that we send the message directly as in the standard stateless PDP.
 
             CacheChange_t* change = nullptr;
             change = history.create_change(
@@ -746,7 +749,7 @@ void PDPClient::announceParticipantState(
 
             if (nullptr != change)
             {
-                // update the sequence number
+                // Update the sequence number
                 change->sequenceNumber = history.next_sequence_number();
                 change->write_params = wp;
 
@@ -764,19 +767,14 @@ void PDPClient::announceParticipantState(
                 //    //locators.push_back(ep.multicastLocatorList);
                 //}
                 {
-                    // temporary workaround
+                    // Temporary workaround
                     eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-                    for (auto& svr : mp_builtin->m_DiscoveryServers)
+                    for (auto& svr: connected_servers_)
                     {
-                        // if we are matched to a server report demise
-                        if (svr.is_connected)
-                        {
-                            //locators.push_back(svr.metatrafficMulticastLocatorList);
-                            locators.push_back(svr.metatrafficUnicastLocatorList);
-                            remote_readers.emplace_back(svr.guidPrefix,
-                                    endpoints->reader.reader_->getGuid().entityId);
-                        }
+                        locators.push_back(svr.metatrafficUnicastLocatorList);
+                        remote_readers.emplace_back(svr.guidPrefix,
+                                endpoints->reader.reader_->getGuid().entityId);
                     }
                 }
 
@@ -786,7 +784,7 @@ void PDPClient::announceParticipantState(
                 }
             }
 
-            // free change
+            // Free change
             history.release_change(change);
         }
         else
@@ -795,7 +793,7 @@ void PDPClient::announceParticipantState(
 
             if (!new_change)
             {
-                // retrieve the participant discovery data
+                // Retrieve the participant discovery data
                 CacheChange_t* pPD;
                 if (history.get_min_change(&pPD))
                 {
@@ -803,11 +801,17 @@ void PDPClient::announceParticipantState(
 
                     eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-                    for (auto& svr : mp_builtin->m_DiscoveryServers)
+                    // An already connected server will be pinged again if there exists a non-connected server (2 or more servers scenario).
+                    // This is because we no longer use the GUID to match servers, so we cannot discern which servers are connected
+                    // and which are not. We cannot map servers in m_DiscoveryServers to connected_servers_.
+
+                    // Ping always not-connected servers. This is done to ensure ping is sent to new servers after a list update.
+                    locators = mp_builtin->m_DiscoveryServers;
+
+                    // Announce liveliness (lease duration) to all servers
+                    if (!_serverPing)
                     {
-                        // non-pinging announcements like lease duration ones must be
-                        // broadcast to all servers
-                        if (!svr.is_connected || !_serverPing)
+                        for (auto& svr : connected_servers_)
                         {
                             locators.push_back(svr.metatrafficMulticastLocatorList);
                             locators.push_back(svr.metatrafficUnicastLocatorList);
@@ -816,8 +820,8 @@ void PDPClient::announceParticipantState(
 
                     direct_send(getRTPSParticipant(), locators, *pPD);
 
-                    // ping done independtly of which triggered the announcement
-                    // note all event callbacks are currently serialized
+                    // Ping done independently of which triggered the announcement.
+                    // Note all event callbacks are currently serialized
                     _serverPing = false;
                 }
                 else
@@ -845,27 +849,18 @@ void PDPClient::update_remote_servers_list()
     {
         eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-        for (const eprosima::fastdds::rtps::RemoteServerAttributes& it : mp_builtin->m_DiscoveryServers)
-        {
-            if (!endpoints->reader.reader_->matched_writer_is_matched(it.GetPDPWriter()) ||
-                    !endpoints->writer.writer_->matched_reader_is_matched(it.GetPDPReader()))
-            {
-                auto entry = LocatorSelectorEntry::create_fully_selected_entry(
-                    it.metatrafficUnicastLocatorList, it.metatrafficMulticastLocatorList);
-                mp_RTPSParticipant->createSenderResources(entry);
-            }
-
-            if (!endpoints->reader.reader_->matched_writer_is_matched(it.GetPDPWriter()))
-            {
-                match_pdp_writer_nts_(it);
-            }
+        // Create resources for remote servers. If a sender resource is already created, this step will be skipped for
+        // that locator.
+        auto entry = LocatorSelectorEntry::create_fully_selected_entry(
+            mp_builtin->m_DiscoveryServers);
+        mp_RTPSParticipant->createSenderResources(entry);
 
-            if (!endpoints->writer.writer_->matched_reader_is_matched(it.GetPDPReader()))
-            {
-                match_pdp_reader_nts_(it);
-            }
-        }
+        BaseReader::downcast(endpoints->reader.reader_)->allow_unknown_writers();
     }
+    // Make at least one ping to the new servers.
+    _serverPing = true;
+    WriteParams __wp = WriteParams::write_params_default();
+    announceParticipantState(false, false, __wp);
     mp_sync->restart_timer();
 }
 
@@ -937,451 +932,6 @@ void PDPClient::match_pdp_reader_nts_(
     }
 }
 
-bool ros_super_client_env()
-{
-    std::string super_client_str;
-    bool super_client = false;
-    std::vector<std::string> true_vec = {"TRUE", "true", "True", "1"};
-    std::vector<std::string> false_vec = {"FALSE", "false", "False", "0"};
-
-    SystemInfo::get_env(ROS_SUPER_CLIENT, super_client_str);
-    if (super_client_str != "")
-    {
-        if (find(true_vec.begin(), true_vec.end(), super_client_str) != true_vec.end())
-        {
-            super_client = true;
-        }
-        else if (find(false_vec.begin(), false_vec.end(), super_client_str) != false_vec.end())
-        {
-            super_client = false;
-        }
-        else
-        {
-            EPROSIMA_LOG_ERROR(RTPS_PDP,
-                    "Invalid value for ROS_SUPER_CLIENT environment variable : " << super_client_str);
-        }
-    }
-    return super_client;
-}
-
-const std::string& ros_discovery_server_env()
-{
-    static std::string servers;
-    SystemInfo::get_env(DEFAULT_ROS2_MASTER_URI, servers);
-    return servers;
-}
-
-bool load_environment_server_info(
-        RemoteServerList_t& attributes)
-{
-    return load_environment_server_info(ros_discovery_server_env(), attributes);
-}
-
-bool load_environment_server_info(
-        const std::string& list,
-        RemoteServerList_t& attributes)
-{
-    attributes.clear();
-    if (list.empty())
-    {
-        return true;
-    }
-
-    /* Parsing ancillary regex
-     * Addresses should be ; separated. IPLocator functions are used to identify them in the order:
-     * IPv4, IPv6 or try dns resolution.
-     **/
-    const static std::regex ROS2_SERVER_LIST_PATTERN(R"(([^;]*);?)");
-    const static std::regex ROS2_IPV4_ADDRESSPORT_PATTERN(R"(^((?:[0-9]{1,3}\.){3}[0-9]{1,3})?:?(?:(\d+))?$)");
-    const static std::regex ROS2_IPV6_ADDRESSPORT_PATTERN(
-        R"(^\[?((?:[0-9a-fA-F]{0,4}\:){0,7}[0-9a-fA-F]{0,4})?(?:\])?:?(?:(\d+))?$)");
-    // Regex to handle DNS and UDPv4/6 expressions
-    const static std::regex ROS2_DNS_DOMAINPORT_PATTERN(R"(^(UDPv[46]?:\[[\w\.:-]{0,63}\]|[\w\.-]{0,63}):?(?:(\d+))?$)");
-    // Regex to handle TCPv4/6 expressions
-    const static std::regex ROS2_DNS_DOMAINPORT_PATTERN_TCP(
-        R"(^(TCPv[46]?:\[[\w\.:-]{0,63}\]):?(?:(\d+))?$)");
-
-    // Filling port info
-    auto process_port = [](int port, Locator_t& server)
-            {
-                if (port > std::numeric_limits<uint16_t>::max())
-                {
-                    throw std::out_of_range("Too large udp port passed into the server's list");
-                }
-
-                if (!IPLocator::setPhysicalPort(server, static_cast<uint16_t>(port)))
-                {
-                    std::stringstream ss;
-                    ss << "Wrong udp port passed into the server's list " << port;
-                    throw std::invalid_argument(ss.str());
-                }
-            };
-
-    // Add new server
-    auto add_server2qos = [](int id, std::forward_list<Locator>&& locators, RemoteServerList_t& attributes)
-            {
-                RemoteServerAttributes server_att;
-
-                // add the server to the list
-                if (!get_server_client_default_guidPrefix(id, server_att.guidPrefix))
-                {
-                    throw std::invalid_argument("The maximum number of default discovery servers has been reached");
-                }
-
-                // split multi and unicast locators
-                auto unicast = std::partition(locators.begin(), locators.end(), IPLocator::isMulticast);
-
-                LocatorList mlist;
-                std::copy(locators.begin(), unicast, std::back_inserter(mlist));
-                if (!mlist.empty())
-                {
-                    server_att.metatrafficMulticastLocatorList.push_back(std::move(mlist));
-                }
-
-                LocatorList ulist;
-                std::copy(unicast, locators.end(), std::back_inserter(ulist));
-                if (!ulist.empty())
-                {
-                    server_att.metatrafficUnicastLocatorList.push_back(std::move(ulist));
-                }
-
-                attributes.push_back(std::move(server_att));
-            };
-
-    try
-    {
-        // Do the parsing and populate the list
-        Locator_t server_locator(LOCATOR_KIND_UDPv4, DEFAULT_ROS2_SERVER_PORT);
-        int server_id = 0;
-
-        std::sregex_iterator server_it(
-            list.begin(),
-            list.end(),
-            ROS2_SERVER_LIST_PATTERN,
-            std::regex_constants::match_not_null);
-
-        while (server_it != std::sregex_iterator())
-        {
-            // Retrieve the address (IPv4, IPv6 or DNS name)
-            const std::smatch::value_type sm = *++(server_it->cbegin());
-
-            if (sm.matched)
-            {
-                // now we must parse the inner expression
-                std::smatch mr;
-                std::string locator(sm);
-
-                if (locator.empty())
-                {
-                    // it's intencionally empty to hint us to ignore this server
-                }
-                // Try first with IPv4
-                else if (std::regex_match(locator, mr, ROS2_IPV4_ADDRESSPORT_PATTERN,
-                        std::regex_constants::match_not_null))
-                {
-                    std::smatch::iterator it = mr.cbegin();
-
-                    // traverse submatches
-                    if (++it != mr.cend())
-                    {
-                        std::string address = it->str();
-                        server_locator.kind = LOCATOR_KIND_UDPv4;
-                        server_locator.set_Invalid_Address();
-
-                        if (!IPLocator::setIPv4(server_locator, address))
-                        {
-                            std::stringstream ss;
-                            ss << "Wrong ipv4 address passed into the server's list " << address;
-                            throw std::invalid_argument(ss.str());
-                        }
-
-                        if (IPLocator::isAny(server_locator))
-                        {
-                            // A server cannot be reach in all interfaces, it's clearly a localhost call
-                            IPLocator::setIPv4(server_locator, "127.0.0.1");
-                        }
-
-                        // get port if any
-                        int port = DEFAULT_ROS2_SERVER_PORT;
-                        if (++it != mr.cend() && it->matched)
-                        {
-                            port = stoi(it->str());
-                        }
-
-                        process_port( port, server_locator);
-                    }
-
-                    // add server to the list
-                    add_server2qos(server_id, std::forward_list<Locator>{server_locator}, attributes);
-                }
-                // Try IPv6 next
-                else if (std::regex_match(locator, mr, ROS2_IPV6_ADDRESSPORT_PATTERN,
-                        std::regex_constants::match_not_null))
-                {
-                    std::smatch::iterator it = mr.cbegin();
-
-                    // traverse submatches
-                    if (++it != mr.cend())
-                    {
-                        std::string address = it->str();
-                        server_locator.kind = LOCATOR_KIND_UDPv6;
-                        server_locator.set_Invalid_Address();
-
-                        if (!IPLocator::setIPv6(server_locator, address))
-                        {
-                            std::stringstream ss;
-                            ss << "Wrong ipv6 address passed into the server's list " << address;
-                            throw std::invalid_argument(ss.str());
-                        }
-
-                        if (IPLocator::isAny(server_locator))
-                        {
-                            // A server cannot be reach in all interfaces, it's clearly a localhost call
-                            IPLocator::setIPv6(server_locator, "::1");
-                        }
-
-                        // get port if any
-                        int port = DEFAULT_ROS2_SERVER_PORT;
-                        if (++it != mr.cend() && it->matched)
-                        {
-                            port = stoi(it->str());
-                        }
-
-                        process_port( port, server_locator);
-                    }
-
-                    // add server to the list
-                    add_server2qos(server_id, std::forward_list<Locator>{server_locator}, attributes);
-                }
-                // try resolve DNS
-                else if (std::regex_match(locator, mr, ROS2_DNS_DOMAINPORT_PATTERN,
-                        std::regex_constants::match_not_null))
-                {
-                    std::forward_list<Locator> flist;
-
-                    {
-                        std::stringstream new_locator(locator,
-                                std::ios_base::in |
-                                std::ios_base::out |
-                                std::ios_base::ate);
-
-                        // first try the formal notation, add default port if necessary
-                        if (!mr[2].matched)
-                        {
-                            new_locator << ":" << DEFAULT_ROS2_SERVER_PORT;
-                        }
-
-                        new_locator >> server_locator;
-                    }
-
-                    // Otherwise add all resolved locators
-                    switch ( server_locator.kind )
-                    {
-                        case LOCATOR_KIND_UDPv4:
-                        case LOCATOR_KIND_UDPv6:
-                            flist.push_front(server_locator);
-                            break;
-                        case LOCATOR_KIND_INVALID:
-                        {
-                            std::smatch::iterator it = mr.cbegin();
-
-                            // traverse submatches
-                            if (++it != mr.cend())
-                            {
-                                std::string domain_name = it->str();
-                                std::set<std::string> ipv4, ipv6;
-                                std::tie(ipv4, ipv6) = IPLocator::resolveNameDNS(domain_name);
-
-                                // get port if any
-                                int port = DEFAULT_ROS2_SERVER_PORT;
-                                if (++it != mr.cend() && it->matched)
-                                {
-                                    port = stoi(it->str());
-                                }
-
-                                for ( const std::string& loc : ipv4 )
-                                {
-                                    server_locator.kind = LOCATOR_KIND_UDPv4;
-                                    server_locator.set_Invalid_Address();
-                                    IPLocator::setIPv4(server_locator, loc);
-
-                                    if (IPLocator::isAny(server_locator))
-                                    {
-                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
-                                        IPLocator::setIPv4(server_locator, "127.0.0.1");
-                                    }
-
-                                    process_port( port, server_locator);
-                                    flist.push_front(server_locator);
-                                }
-
-                                for ( const std::string& loc : ipv6 )
-                                {
-                                    server_locator.kind = LOCATOR_KIND_UDPv6;
-                                    server_locator.set_Invalid_Address();
-                                    IPLocator::setIPv6(server_locator, loc);
-
-                                    if (IPLocator::isAny(server_locator))
-                                    {
-                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
-                                        IPLocator::setIPv6(server_locator, "::1");
-                                    }
-
-                                    process_port( port, server_locator);
-                                    flist.push_front(server_locator);
-                                }
-                            }
-                        }
-                    }
-
-                    if (flist.empty())
-                    {
-                        std::stringstream ss;
-                        ss << "Wrong domain name passed into the server's list " << locator;
-                        throw std::invalid_argument(ss.str());
-                    }
-
-                    // add server to the list
-                    add_server2qos(server_id, std::move(flist), attributes);
-                }
-                // try resolve TCP DNS
-                else if (std::regex_match(locator, mr, ROS2_DNS_DOMAINPORT_PATTERN_TCP,
-                        std::regex_constants::match_not_null))
-                {
-                    std::forward_list<Locator> flist;
-
-                    {
-                        std::stringstream new_locator(locator,
-                                std::ios_base::in |
-                                std::ios_base::out |
-                                std::ios_base::ate);
-
-                        // first try the formal notation, add default port if necessary
-                        if (!mr[2].matched)
-                        {
-                            new_locator << ":" << DEFAULT_TCP_SERVER_PORT;
-                        }
-
-                        new_locator >> server_locator;
-                    }
-
-                    // Otherwise add all resolved locators
-                    switch ( server_locator.kind )
-                    {
-                        case LOCATOR_KIND_TCPv4:
-                        case LOCATOR_KIND_TCPv6:
-                            IPLocator::setLogicalPort(server_locator, static_cast<uint16_t>(server_locator.port));
-                            flist.push_front(server_locator);
-                            break;
-                        case LOCATOR_KIND_INVALID:
-                        {
-                            std::smatch::iterator it = mr.cbegin();
-
-                            // traverse submatches
-                            if (++it != mr.cend())
-                            {
-                                std::string domain_name = it->str();
-                                std::set<std::string> ipv4, ipv6;
-                                std::tie(ipv4, ipv6) = IPLocator::resolveNameDNS(domain_name);
-
-                                // get port if any
-                                int port = DEFAULT_TCP_SERVER_PORT;
-                                if (++it != mr.cend() && it->matched)
-                                {
-                                    port = stoi(it->str());
-                                }
-
-                                for ( const std::string& loc : ipv4 )
-                                {
-                                    server_locator.kind = LOCATOR_KIND_TCPv4;
-                                    server_locator.set_Invalid_Address();
-                                    IPLocator::setIPv4(server_locator, loc);
-
-                                    if (IPLocator::isAny(server_locator))
-                                    {
-                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
-                                        IPLocator::setIPv4(server_locator, "127.0.0.1");
-                                    }
-
-                                    process_port( port, server_locator);
-                                    IPLocator::setLogicalPort(server_locator, static_cast<uint16_t>(port));
-                                    flist.push_front(server_locator);
-                                }
-
-                                for ( const std::string& loc : ipv6 )
-                                {
-                                    server_locator.kind = LOCATOR_KIND_TCPv6;
-                                    server_locator.set_Invalid_Address();
-                                    IPLocator::setIPv6(server_locator, loc);
-
-                                    if (IPLocator::isAny(server_locator))
-                                    {
-                                        // A server cannot be reach in all interfaces, it's clearly a localhost call
-                                        IPLocator::setIPv6(server_locator, "::1");
-                                    }
-
-                                    process_port( port, server_locator);
-                                    IPLocator::setLogicalPort(server_locator, static_cast<uint16_t>(port));
-                                    flist.push_front(server_locator);
-                                }
-                            }
-                        }
-                    }
-
-                    if (flist.empty())
-                    {
-                        std::stringstream ss;
-                        ss << "Wrong domain name passed into the server's list " << locator;
-                        throw std::invalid_argument(ss.str());
-                    }
-
-                    // add server to the list
-                    add_server2qos(server_id, std::move(flist), attributes);
-                }
-                else
-                {
-                    std::stringstream ss;
-                    ss << "Wrong locator passed into the server's list " << locator;
-                    throw std::invalid_argument(ss.str());
-                }
-            }
-
-            // advance to the next server if any
-            ++server_id;
-            ++server_it;
-        }
-
-        // Check for server info
-        if (attributes.empty())
-        {
-            throw std::invalid_argument("No default server locators were provided.");
-        }
-    }
-    catch (std::exception& e)
-    {
-        EPROSIMA_LOG_ERROR(SERVER_CLIENT_DISCOVERY, e.what());
-        attributes.clear();
-        return false;
-    }
-
-    return true;
-}
-
-GUID_t RemoteServerAttributes::GetParticipant() const
-{
-    return GUID_t(guidPrefix, c_EntityId_RTPSParticipant);
-}
-
-GUID_t RemoteServerAttributes::GetPDPReader() const
-{
-    return GUID_t(guidPrefix, c_EntityId_SPDPReader);
-}
-
-GUID_t RemoteServerAttributes::GetPDPWriter() const
-{
-    return GUID_t(guidPrefix, c_EntityId_SPDPWriter);
-}
-
 bool get_server_client_default_guidPrefix(
         int id,
         GuidPrefix_t& guid)
@@ -1422,11 +972,17 @@ bool PDPClient::remove_remote_participant(
     rguid.entityId = endpoints->reader.reader_->getGuid().entityId;
     endpoints->writer.writer_->matched_reader_remove(rguid);
 
-    update_remote_servers_list();
+    // Reactivate ping routine
+    mp_sync->restart_timer();
 
     return false;
 }
 
+const std::list<eprosima::fastdds::rtps::RemoteServerAttributes>& PDPClient::connected_servers()
+{
+    return connected_servers_;
+}
+
 } /* namespace rtps */
 } /* namespace fastdds */
 } /* namespace eprosima */
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPClient.h b/src/cpp/rtps/builtin/discovery/participant/PDPClient.h
index 96aecb2c4f1..40e590cdec0 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPClient.h
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPClient.h
@@ -21,6 +21,7 @@
 #define _FASTDDS_RTPS_PDPCLIENT_H_
 #ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
 
+#include <rtps/attributes/ServerAttributes.hpp>
 #include <rtps/builtin/discovery/participant/DS/DiscoveryServerPDPEndpoints.hpp>
 #include <rtps/builtin/discovery/participant/DS/DiscoveryServerPDPEndpointsSecure.hpp>
 #include <rtps/builtin/discovery/participant/PDP.h>
@@ -152,6 +153,12 @@ class PDPClient : public PDP
      */
     void update_remote_servers_list();
 
+    /**
+     * Get the list of remote servers to which the client is already connected.
+     * @return A reference to the list of RemoteServerAttributes
+     */
+    const fastdds::rtps::RemoteServerList_t& connected_servers();
+
 protected:
 
     void update_builtin_locators() override;
@@ -253,6 +260,9 @@ class PDPClient : public PDP
 
     //! flag to know this client must use super client participant type
     bool _super_client;
+
+    //! List of real connected servers
+    std::list<eprosima::fastdds::rtps::RemoteServerAttributes> connected_servers_;
 };
 
 } /* namespace rtps */
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp b/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
index f8048d43096..a8726aea8e3 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
@@ -60,13 +60,11 @@ PDPServer::PDPServer(
         DurabilityKind_t durability_kind /* TRANSIENT_LOCAL */)
     : PDP(builtin, allocation)
     , routine_(nullptr)
-    , ping_(nullptr)
-    , discovery_db_(builtin->mp_participantImpl->getGuid().guidPrefix,
-            servers_prefixes())
+    , discovery_db_(builtin->mp_participantImpl->getGuid().guidPrefix)
     , durability_ (durability_kind)
 {
     // Add remote servers from environment variable
-    RemoteServerList_t env_servers;
+    LocatorList_t env_servers;
     {
         std::lock_guard<std::recursive_mutex> lock(*getMutex());
 
@@ -79,7 +77,6 @@ PDPServer::PDPServer(
                     mp_builtin->m_DiscoveryServers.push_back(server);
                 }
                 m_discovery.discovery_config.m_DiscoveryServers.push_back(server);
-                discovery_db_.add_server(server.guidPrefix);
             }
         }
     }
@@ -89,14 +86,12 @@ PDPServer::~PDPServer()
 {
     // Stop timed events
     routine_->cancel_timer();
-    ping_->cancel_timer();
 
     // Disable database
     discovery_db_.disable();
 
     // Delete timed events
     delete(routine_);
-    delete(ping_);
 
     // Clear ddb and release its changes
     process_changes_release_(discovery_db_.clear());
@@ -110,7 +105,7 @@ bool PDPServer::init(
         return false;
     }
 
-    //INIT EDP
+    // INIT EDP
     mp_EDP = new EDPServer(this, mp_RTPSParticipant, durability_);
     if (!mp_EDP->initEDP(m_discovery))
     {
@@ -138,15 +133,6 @@ bool PDPServer::init(
                     TimeConv::Duration_t2MilliSecondsDouble(
                         m_discovery.discovery_config.discoveryServer_client_syncperiod));
 
-    /*
-        Given the fact that a participant is either a client or a server the
-        discoveryServer_client_syncperiod parameter has a context defined meaning.
-     */
-    ping_ = new DServerPingEvent(this,
-                    TimeConv::Duration_t2MilliSecondsDouble(
-                        m_discovery.discovery_config.discoveryServer_client_syncperiod));
-    ping_->restart_timer();
-
     return true;
 }
 
@@ -196,24 +182,19 @@ ParticipantProxyData* PDPServer::createParticipantProxyData(
 {
     std::lock_guard<std::recursive_mutex> lock(*getMutex());
 
-    // lease duration is controlled for owned clients or linked servers
-    // other clients liveliness is provided through server's PDP discovery data
+    // Lease duration is controlled for owned clients or linked servers.
+    // Other clients liveliness is provided through server's PDP discovery data
 
-    // check if the DATA msg is relayed by another server
+    // Check if the DATA msg is relayed by another server
     bool do_lease = participant_data.m_guid.guidPrefix == writer_guid.guidPrefix;
 
     if (!do_lease)
     {
-        // if not a client verify this participant is a server
+        // If not a client verify this participant is a server
+        std::string part_type = check_participant_type(participant_data.m_properties);
+        if (part_type == ParticipantType::SERVER || part_type == ParticipantType::BACKUP)
         {
-            eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
-            for (auto& svr : mp_builtin->m_DiscoveryServers)
-            {
-                if (data_matches_with_prefix(svr.guidPrefix, participant_data))
-                {
-                    do_lease = true;
-                }
-            }
+            do_lease = true;
         }
     }
 
@@ -287,7 +268,7 @@ bool PDPServer::create_ds_pdp_best_effort_reader(
     ratt.endpoint.external_unicast_locators = mp_builtin->m_att.metatraffic_external_unicast_locators;
     ratt.endpoint.ignore_non_matching_locators = pattr.ignore_non_matching_locators;
     ratt.endpoint.topicKind = WITH_KEY;
-    // change depending of backup mode
+    // Change depending on backup mode
     ratt.endpoint.durabilityKind = VOLATILE;
     ratt.endpoint.reliabilityKind = BEST_EFFORT;
 
@@ -354,6 +335,7 @@ bool PDPServer::create_ds_pdp_reliable_endpoints(
         DiscoveryServerPDPEndpoints& endpoints,
         bool secure)
 {
+    static_cast<void>(secure);
     const RTPSParticipantAttributes& pattr = mp_RTPSParticipant->getRTPSParticipantAttributes();
 
     /***********************************
@@ -375,7 +357,7 @@ bool PDPServer::create_ds_pdp_reliable_endpoints(
     ratt.endpoint.external_unicast_locators = mp_builtin->m_att.metatraffic_external_unicast_locators;
     ratt.endpoint.ignore_non_matching_locators = pattr.ignore_non_matching_locators;
     ratt.endpoint.topicKind = WITH_KEY;
-    // change depending of backup mode
+    // Change depending on backup mode
     ratt.endpoint.durabilityKind = durability_;
     ratt.endpoint.reliabilityKind = RELIABLE;
     ratt.times.heartbeat_response_delay = pdp_heartbeat_response_delay;
@@ -409,8 +391,13 @@ bool PDPServer::create_ds_pdp_reliable_endpoints(
     {
         endpoints.reader.reader_ = dynamic_cast<fastdds::rtps::StatefulReader*>(reader);
 
-        // Enable unknown clients to reach this reader
-        BaseReader::downcast(endpoints.reader.reader_)->allow_unknown_writers();
+#if HAVE_SECURITY
+        if (!secure)
+#endif  // HAVE_SECURITY
+        {
+            // Enable unknown clients to reach this reader
+            BaseReader::downcast(endpoints.reader.reader_)->allow_unknown_writers();
+        }
 
 #if HAVE_SECURITY
         mp_RTPSParticipant->set_endpoint_rtps_protection_supports(reader, false);
@@ -498,23 +485,13 @@ bool PDPServer::create_ds_pdp_reliable_endpoints(
     // TODO check if this should be done here or before this point in creation
     endpoints.writer.history_->remove_all_changes();
 
-    // Perform matching with remote servers and ensure output channels are open in the transport for the corresponding
-    // locators
+    // Ensure output channels are open in the transport for the corresponding locators
     {
         eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-        for (const eprosima::fastdds::rtps::RemoteServerAttributes& it : mp_builtin->m_DiscoveryServers)
-        {
-            auto entry = LocatorSelectorEntry::create_fully_selected_entry(
-                it.metatrafficUnicastLocatorList, it.metatrafficMulticastLocatorList);
-            mp_RTPSParticipant->createSenderResources(entry);
-
-            if (!secure)
-            {
-                match_pdp_writer_nts_(it);
-                match_pdp_reader_nts_(it);
-            }
-        }
+        auto entry = LocatorSelectorEntry::create_fully_selected_entry(
+            mp_builtin->m_DiscoveryServers);
+        mp_RTPSParticipant->createSenderResources(entry);
     }
 
     return true;
@@ -574,7 +551,7 @@ void PDPServer::match_reliable_pdp_endpoints(
     bool use_multicast_locators = !mp_RTPSParticipant->getAttributes().builtin.avoid_builtin_multicast ||
             pdata.metatraffic_locators.unicast.empty();
 
-    // only SERVER and CLIENT participants will be received. All builtin must be there
+    // Only SERVER and CLIENT participants will be received. All builtin must be there
     uint32_t auxendp = endp &
             (DISC_BUILTIN_ENDPOINT_PARTICIPANT_ANNOUNCER |
             DISC_BUILTIN_ENDPOINT_PARTICIPANT_SECURE_ANNOUNCER);
@@ -610,7 +587,7 @@ void PDPServer::match_reliable_pdp_endpoints(
         return;
     }
 
-    // only SERVER and CLIENT participants will be received. All builtin must be there
+    // Only SERVER and CLIENT participants will be received. All builtin must be there
     auxendp = endp & (DISC_BUILTIN_ENDPOINT_PARTICIPANT_DETECTOR | DISC_BUILTIN_ENDPOINT_PARTICIPANT_SECURE_DETECTOR);
     if (0 != auxendp)
     {
@@ -647,8 +624,28 @@ void PDPServer::match_reliable_pdp_endpoints(
 void PDPServer::assignRemoteEndpoints(
         ParticipantProxyData* pdata)
 {
-    EPROSIMA_LOG_INFO(RTPS_PDP_SERVER, "Assigning remote endpoint for RTPSParticipant: " << pdata->m_guid.guidPrefix);
+    std::string part_type;
+    {
+        eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
+        // If the received participant GUID is from a server, update the servers list and DB and match the endpoints
+        part_type = check_participant_type(pdata->m_properties);
+        if (part_type == ParticipantType::SERVER || part_type == ParticipantType::BACKUP)
+        {
+            // Update DisvoveryDataBase
+            discovery_db_.add_server(pdata->m_guid.guidPrefix);
+
+#if HAVE_SECURITY
+            if (!should_protect_discovery())
+#endif // HAVE_SECURITY
+            {
+                match_pdp_writer_nts_(*pdata);
+                match_pdp_reader_nts_(*pdata);
+            }
+        }
+    }
+    EPROSIMA_LOG_INFO(RTPS_PDP_SERVER,
+            "Assigning remote endpoint for " << part_type << ": " << pdata->m_guid.guidPrefix);
     match_reliable_pdp_endpoints(*pdata);
 
 #if HAVE_SECURITY
@@ -657,6 +654,12 @@ void PDPServer::assignRemoteEndpoints(
     {
         perform_builtin_endpoints_matching(*pdata);
     }
+
+    // Send the Data(p) to the client
+    if (part_type == ParticipantType::CLIENT || part_type == ParticipantType::SUPER_CLIENT)
+    {
+        discovery_db().add_own_pdp_to_send_();
+    }
 }
 
 void PDPServer::notifyAboveRemoteEndpoints(
@@ -705,7 +708,7 @@ bool PDPServer::pairing_remote_reader_with_local_writer_after_security(
 void PDPServer::perform_builtin_endpoints_matching(
         const ParticipantProxyData& pdata)
 {
-    //Inform EDP of new RTPSParticipant data:
+    // Inform EDP of new RTPSParticipant data:
     if (mp_EDP != nullptr)
     {
         mp_EDP->assignRemoteEndpoints(pdata, true);
@@ -750,6 +753,14 @@ void PDPServer::removeRemoteEndpoints(
                                                            << " did not send information about builtin readers");
         return;
     }
+
+    // Remove remote server
+    std::string part_type = check_participant_type(pdata->m_properties);
+    if (part_type == ParticipantType::SERVER || part_type == ParticipantType::BACKUP)
+    {
+        eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
+        discovery_db_.remove_server(pdata->m_guid.guidPrefix);
+    }
 }
 
 std::ostringstream PDPServer::get_persistence_file_name_() const
@@ -873,7 +884,7 @@ void PDPServer::announceParticipantState(
                         return;
                     }
 
-                    // assign identity
+                    // Assign identity
                     change->sequenceNumber = sn;
 
                     // Create a RemoteLocatorList for metatraffic_locators
@@ -913,7 +924,7 @@ void PDPServer::announceParticipantState(
                     }
                 }
                 // Doesn't make sense to send the DATA directly if it hasn't been introduced in the history yet (missing
-                // sequence number.
+                // sequence number).
                 return;
             }
             else
@@ -934,6 +945,9 @@ void PDPServer::announceParticipantState(
                     return;
                 }
             }
+
+            // Ping remote servers. It is done separately to avoid setting wrong remote_readers
+            ping_remote_servers();
         }
         else
         {
@@ -973,7 +987,7 @@ void PDPServer::announceParticipantState(
                 }
                 else
                 {
-                    // Dispose if already there
+                    // Dispose if already there.
                     // It may happen if the participant is not removed fast enough
                     history.release_change(change);
                     return;
@@ -981,7 +995,7 @@ void PDPServer::announceParticipantState(
             }
             else
             {
-                // failed to create the disposal change
+                // Failed to create the disposal change
                 EPROSIMA_LOG_ERROR(RTPS_PDP_SERVER, "Server failed to create its DATA(Up)");
                 return;
             }
@@ -1056,24 +1070,24 @@ bool PDPServer::remove_remote_participant(
             // Notify the database
             if (discovery_db_.update(pC, ddb::DiscoveryParticipantChangeData()))
             {
-                // assure processing time for the cache
+                // Ensure processing time for the cache
                 awake_routine_thread();
 
-                // the discovery database takes ownership of the CacheChange_t
-                // henceforth there are no references to the CacheChange_t
+                // The discovery database takes ownership of the CacheChange_t
+                // Henceforth, there are no references to the CacheChange_t
             }
             else
             {
-                // if the database doesn't take the ownership remove
+                // If the database doesn't take the ownership remove
                 endpoints->reader.reader_->release_cache(pC);
             }
         }
     }
 
-    // check if is a server who has been disposed
-    awake_server_thread();
+    // Resend participant announcements to try to reconnect faster
+    resend_ininitial_announcements();
 
-    // delegate into the base class for inherited proxy database removal
+    // Delegate into the base class for inherited proxy database removal
     return PDP::remove_remote_participant(partGUID, reason);
 }
 
@@ -1092,11 +1106,6 @@ void PDPServer::awake_routine_thread(
     routine_->restart_timer();
 }
 
-void PDPServer::awake_server_thread()
-{
-    ping_->restart_timer();
-}
-
 bool PDPServer::server_update_routine()
 {
     // There is pending work to be done by the server if there are changes that have not been acknowledged.
@@ -1161,38 +1170,20 @@ void PDPServer::update_remote_servers_list()
         return;
     }
 
-    std::lock_guard<std::recursive_mutex> lock(*getMutex());
-
-    eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
-
-    for (const eprosima::fastdds::rtps::RemoteServerAttributes& it : mp_builtin->m_DiscoveryServers)
     {
-        if (!endpoints->reader.reader_->matched_writer_is_matched(it.GetPDPWriter()) ||
-                !endpoints->writer.writer_->matched_reader_is_matched(it.GetPDPReader()))
-        {
-            auto entry = LocatorSelectorEntry::create_fully_selected_entry(
-                it.metatrafficUnicastLocatorList, it.metatrafficMulticastLocatorList);
-            mp_RTPSParticipant->createSenderResources(entry);
-        }
-
-        if (!endpoints->reader.reader_->matched_writer_is_matched(it.GetPDPWriter()))
-        {
-            match_pdp_writer_nts_(it);
-        }
+        std::lock_guard<std::recursive_mutex> lock(*getMutex());
 
-        if (!endpoints->writer.writer_->matched_reader_is_matched(it.GetPDPReader()))
-        {
-            match_pdp_reader_nts_(it);
-        }
-    }
+        eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
 
-    for (auto server : mp_builtin->m_DiscoveryServers)
-    {
-        discovery_db_.add_server(server.guidPrefix);
+        // Create resources for remote servers. If a sender resource is already created, this step will be skipped for
+        // that locator.
+        auto entry = LocatorSelectorEntry::create_fully_selected_entry(
+            mp_builtin->m_DiscoveryServers);
+        mp_RTPSParticipant->createSenderResources(entry);
     }
 
     // Need to reactivate the server thread to send the DATA(p) to the new servers
-    awake_server_thread();
+    resend_ininitial_announcements();
 }
 
 bool PDPServer::process_writers_acknowledgements()
@@ -1202,7 +1193,7 @@ bool PDPServer::process_writers_acknowledgements()
     auto endpoints = static_cast<fastdds::rtps::DiscoveryServerPDPEndpoints*>(builtin_endpoints_.get());
 
     // Execute first ACK for endpoints because PDP acked changes relevance in EDP,
-    //  which can result in false positives in EDP acknowledgements.
+    // which can result in false positives in EDP acknowledgements.
 
     /* EDP Subscriptions Writer's History */
     EDPServer* edp = static_cast<EDPServer*>(mp_EDP);
@@ -1291,8 +1282,8 @@ History::iterator PDPServer::process_change_acknowledgement(
             // Remove entry from `participants_|writers_|readers_`
             // AND put the change in changes_release
             discovery_db_.delete_entity_of_change(c);
-            // Remove from writer's history
-            // remove false because the clean of the change is made by release_change of ddb
+            // Remove from writer's history.
+            // Using `false` on `release` since the clean-up of the change is made by release_change of ddb
             return writer_history->remove_change(cit, false);
         }
     }
@@ -1335,14 +1326,20 @@ bool PDPServer::process_disposals()
             eprosima::fastdds::rtps::WriteParams wp = change->write_params;
             endpoints->writer.history_->add_change(change, wp);
         }
-        // Check whether disposals contains a DATA(Up) from the same participant as the DATA(Uw) or DATA(Ur).
-        // If it does, then there is no need of adding the DATA(Uw) or DATA(Ur).
+        // Data(Uw|Ur) case
         else
         {
             // Check whether disposals contains a DATA(Up) from the same participant as the DATA(Uw/r).
             // If it does, then there is no need of adding the DATA(Uw/r).
             bool should_publish_disposal = !announcement_from_same_participant_in_disposals(disposals,
                             change_guid_prefix);
+            auto direct_participants = discovery_db_.direct_clients_and_servers();
+            bool our_client =
+                    (std::find(direct_participants.begin(), direct_participants.end(),
+                    change_guid_prefix) != direct_participants.end());
+            bool is_server_responsible =
+                    (our_client || (change_guid_prefix == mp_RTPSParticipant->getGuid().guidPrefix));
+            should_publish_disposal = should_publish_disposal && is_server_responsible;
             if (!edp->process_disposal(change, discovery_db_, change_guid_prefix, should_publish_disposal))
             {
                 EPROSIMA_LOG_ERROR(RTPS_PDP_SERVER_DISPOSAL,
@@ -1374,7 +1371,7 @@ void PDPServer::process_changes_release_(
     for (auto ch : changes)
     {
         // Check if change owner is this participant. In that case, the change comes from a writer pool (PDP, EDP
-        // publications or EDP subscriptions)
+        // publications or EDP subscriptions).
         // We compare the instance handle, as the only changes from our own server are its owns
         if (discovery_db().guid_from_change(ch) == endpoints->writer.writer_->getGuid())
         {
@@ -1454,7 +1451,7 @@ fastdds::rtps::ddb::DiscoveryDataBase& PDPServer::discovery_db()
     return discovery_db_;
 }
 
-const RemoteServerList_t& PDPServer::servers()
+const LocatorList_t& PDPServer::servers()
 {
     return mp_builtin->m_DiscoveryServers;
 }
@@ -1571,59 +1568,29 @@ bool PDPServer::pending_ack()
     return ret;
 }
 
-std::set<fastdds::rtps::GuidPrefix_t> PDPServer::servers_prefixes()
-{
-    std::lock_guard<std::recursive_mutex> lock(*getMutex());
-    std::set<GuidPrefix_t> servers;
-    eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
-
-    for (const eprosima::fastdds::rtps::RemoteServerAttributes& it : mp_builtin->m_DiscoveryServers)
-    {
-        servers.insert(it.guidPrefix);
-    }
-    return servers;
-}
-
 eprosima::fastdds::rtps::ResourceEvent& PDPServer::get_resource_event_thread()
 {
     return resource_event_thread_;
 }
 
-bool PDPServer::all_servers_acknowledge_pdp()
-{
-    // check if already initialized
-    auto endpoints = static_cast<fastdds::rtps::DiscoveryServerPDPEndpoints*>(builtin_endpoints_.get());
-    static_cast<void>(endpoints);
-    assert(endpoints->writer.history_ && endpoints->writer.writer_);
-
-    return discovery_db_.server_acked_by_my_servers();
-}
-
 void PDPServer::ping_remote_servers()
 {
-    // Get the servers that have not ACKed this server's DATA(p)
-    std::vector<GuidPrefix_t> ack_pending_servers = discovery_db_.ack_pending_servers();
+    LocatorList locators_ping;
     std::vector<GUID_t> remote_readers;
-    LocatorList locators;
 
     // Iterate over the list of servers
     {
-        std::lock_guard<std::recursive_mutex> lock(*getMutex());
         eprosima::shared_lock<eprosima::shared_mutex> disc_lock(mp_builtin->getDiscoveryMutex());
+        // Get the info to send to these already known locators
+        locators_ping = mp_builtin->m_DiscoveryServers;
+    }
 
-        for (auto& server : mp_builtin->m_DiscoveryServers)
-        {
-
-            // If the server is the the ack_pending list, then add its GUID and locator to send the announcement
-            auto server_it = std::find(ack_pending_servers.begin(), ack_pending_servers.end(), server.guidPrefix);
-            if (server_it != ack_pending_servers.end())
-            {
-                // get the info to send to this already known locators
-                locators.push_back(server.metatrafficUnicastLocatorList);
-            }
-        }
+    if (!locators_ping.empty())
+    {
+        EPROSIMA_LOG_INFO(RTPS_PDP_SERVER,
+                "Server " << getRTPSParticipant()->getGuid() << " PDP announcement");
+        send_announcement(discovery_db().cache_change_own_participant(), remote_readers, locators_ping);
     }
-    send_announcement(discovery_db().cache_change_own_participant(), remote_readers, locators);
 }
 
 void PDPServer::send_announcement(
@@ -1788,16 +1755,16 @@ bool PDPServer::process_backup_discovery_database_restore(
                 }
             }
 
-            // deserialize from json to change already created
+            // Deserialize from json to change already created
             ddb::from_json(it.value()["change"], *change_aux);
 
             changes_map.insert(
                 std::make_pair(change_aux->instanceHandle, change_aux));
 
             // TODO refactor for multiple servers
-            // should not send the virtual changes by the listener
-            // should store in DDB if it is local even for endpoints
-            // call listener to create proxy info for other entities different than server
+            // Should not send the virtual changes by the listener.
+            // Should store in DDB if it is local even for endpoints.
+            // Call listener to create proxy info for other entities different than server.
             if (change_aux->write_params.sample_identity().writer_guid().guidPrefix !=
                     endpoints->writer.writer_->getGuid().guidPrefix
                     && change_aux->kind == fastdds::rtps::ALIVE
@@ -1827,13 +1794,13 @@ bool PDPServer::process_backup_discovery_database_restore(
                 }
             }
 
-            // deserialize from json to change already created
+            // Deserialize from json to change already created
             ddb::from_json(it.value()["change"], *change_aux);
 
             changes_map.insert(
                 std::make_pair(change_aux->instanceHandle, change_aux));
 
-            // call listener to create proxy info for other entities different than server
+            // Call listener to create proxy info for other entities different than server
             if (change_aux->write_params.sample_identity().writer_guid().guidPrefix !=
                     endpoints->writer.writer_->getGuid().guidPrefix
                     && change_aux->kind == fastdds::rtps::ALIVE
@@ -1843,7 +1810,7 @@ bool PDPServer::process_backup_discovery_database_restore(
             }
         }
 
-        // load database
+        // Load database
         discovery_db_.from_json(j, changes_map);
     }
     catch (std::ios_base::failure&)
@@ -2006,35 +1973,55 @@ void PDPServer::process_backup_store()
 }
 
 void PDPServer::match_pdp_writer_nts_(
-        const eprosima::fastdds::rtps::RemoteServerAttributes& server_att)
+        const ParticipantProxyData& pdata)
 {
     auto endpoints = static_cast<fastdds::rtps::DiscoveryServerPDPEndpoints*>(builtin_endpoints_.get());
     const NetworkFactory& network = mp_RTPSParticipant->network_factory();
     auto temp_writer_data = get_temporary_writer_proxies_pool().get();
 
     temp_writer_data->clear();
-    temp_writer_data->guid(server_att.GetPDPWriter());
-    temp_writer_data->set_multicast_locators(server_att.metatrafficMulticastLocatorList, network);
-    temp_writer_data->set_remote_unicast_locators(server_att.metatrafficUnicastLocatorList, network);
+    temp_writer_data->guid({ pdata.m_guid.guidPrefix, endpoints->writer.writer_->getGuid().entityId });
+    temp_writer_data->set_remote_locators(pdata.metatraffic_locators, network, true);
     temp_writer_data->m_qos.m_durability.durabilityKind(durability_);
     temp_writer_data->m_qos.m_reliability.kind = dds::RELIABLE_RELIABILITY_QOS;
-    endpoints->reader.reader_->matched_writer_add(*temp_writer_data);
+#if HAVE_SECURITY
+    if (should_protect_discovery())
+    {
+        mp_RTPSParticipant->security_manager().discovered_builtin_writer(
+            endpoints->reader.reader_->getGuid(), { pdata.m_guid.guidPrefix, c_EntityId_RTPSParticipant },
+            *temp_writer_data, endpoints->reader.reader_->getAttributes().security_attributes());
+    }
+    else
+#endif // HAVE_SECURITY
+    {
+        endpoints->reader.reader_->matched_writer_add(*temp_writer_data);
+    }
 }
 
 void PDPServer::match_pdp_reader_nts_(
-        const eprosima::fastdds::rtps::RemoteServerAttributes& server_att)
+        const ParticipantProxyData& pdata)
 {
     auto endpoints = static_cast<fastdds::rtps::DiscoveryServerPDPEndpoints*>(builtin_endpoints_.get());
     const NetworkFactory& network = mp_RTPSParticipant->network_factory();
     auto temp_reader_data = get_temporary_reader_proxies_pool().get();
 
     temp_reader_data->clear();
-    temp_reader_data->guid(server_att.GetPDPReader());
-    temp_reader_data->set_multicast_locators(server_att.metatrafficMulticastLocatorList, network);
-    temp_reader_data->set_remote_unicast_locators(server_att.metatrafficUnicastLocatorList, network);
+    temp_reader_data->guid({ pdata.m_guid.guidPrefix, endpoints->reader.reader_->getGuid().entityId });
+    temp_reader_data->set_remote_locators(pdata.metatraffic_locators, network, true);
     temp_reader_data->m_qos.m_durability.kind = dds::TRANSIENT_LOCAL_DURABILITY_QOS;
     temp_reader_data->m_qos.m_reliability.kind = dds::RELIABLE_RELIABILITY_QOS;
-    endpoints->writer.writer_->matched_reader_add(*temp_reader_data);
+#if HAVE_SECURITY
+    if (should_protect_discovery())
+    {
+        mp_RTPSParticipant->security_manager().discovered_builtin_reader(
+            endpoints->writer.writer_->getGuid(), { pdata.m_guid.guidPrefix, c_EntityId_RTPSParticipant },
+            *temp_reader_data, endpoints->writer.writer_->getAttributes().security_attributes());
+    }
+    else
+#endif // HAVE_SECURITY
+    {
+        endpoints->writer.writer_->matched_reader_add(*temp_reader_data);
+    }
 }
 
 void PDPServer::release_change_from_writer(
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPServer.hpp b/src/cpp/rtps/builtin/discovery/participant/PDPServer.hpp
index 792b2b64f52..3dd6a6bab3a 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPServer.hpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPServer.hpp
@@ -28,8 +28,8 @@
 #include <string>
 #include <vector>
 
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
 #include <fastdds/rtps/history/History.hpp>
+#include <rtps/attributes/ServerAttributes.hpp>
 #include <rtps/builtin/discovery/database/DiscoveryDataBase.hpp>
 #include <rtps/builtin/discovery/database/DiscoveryDataFilter.hpp>
 #include <rtps/builtin/discovery/participant/DS/DiscoveryServerPDPEndpointsSecure.hpp>
@@ -127,7 +127,7 @@ class PDPServer : public fastdds::rtps::PDP
             bool dispose = false,
             fastdds::rtps::WriteParams& wparams = fastdds::rtps::WriteParams::WRITE_PARAM_DEFAULT) override;
 
-    // Force the sending of our DATA(p) to those servers that has not acked yet
+    // Force the sending of our DATA(p) to those servers in the initial server list
     void ping_remote_servers();
 
     // send a specific Data to specific locators
@@ -179,15 +179,6 @@ class PDPServer : public fastdds::rtps::PDP
     void awake_routine_thread(
             double interval_ms = 0);
 
-    void awake_server_thread();
-
-    /**
-     * Check if all servers have acknowledge this server PDP data
-     * This method must be called from a mutex protected context.
-     * @return True if all can reach the client
-     */
-    bool all_servers_acknowledge_pdp();
-
     /* The server's main routine. This includes all the discovery related tasks that the server needs to run
      * periodically to keep the discovery graph updated.
      * @return: True if there is pending work, false otherwise.
@@ -202,12 +193,12 @@ class PDPServer : public fastdds::rtps::PDP
     fastdds::rtps::ddb::DiscoveryDataBase& discovery_db();
 
     /**
-     * Access to the remote servers list
+     * Access to the remote servers locators list
      * This method is not thread safe.
      * The return reference may be invalidated if the user modifies simultaneously the remote server list.
-     * @return constant reference to the remote servers list
+     * @return constant reference to the remote servers locators list
      */
-    const RemoteServerList_t& servers();
+    const LocatorList& servers();
 
 protected:
 
@@ -286,8 +277,6 @@ class PDPServer : public fastdds::rtps::PDP
             nlohmann::json& ddb_json,
             std::vector<nlohmann::json>& new_changes);
 
-    std::set<fastdds::rtps::GuidPrefix_t> servers_prefixes();
-
     // General file name for the prefix of every backup file
     std::ostringstream get_persistence_file_name_() const;
 
@@ -299,20 +288,20 @@ class PDPServer : public fastdds::rtps::PDP
     void process_backup_store();
 
     /**
-     * Manually match the local PDP reader with the PDP writer of a given server. The function is
-     * not thread safe (nts) in the sense that it does not take the PDP mutex. It does however take
-     * temp_data_lock_
+     * Manually match the local PDP reader with the PDP writer of a given partipant of type server.
+     * The function is not thread safe (nts) in the sense that it does not take the PDP mutex.
+     * It does however take temp_data_lock_
      */
     void match_pdp_writer_nts_(
-            const eprosima::fastdds::rtps::RemoteServerAttributes& server_att);
+            const fastdds::rtps::ParticipantProxyData& pdata);
 
     /**
-     * Manually match the local PDP writer with the PDP reader of a given server. The function is
-     * not thread safe (nts) in the sense that it does not take the PDP mutex. It does however take
-     * temp_data_lock_
+     * Manually match the local PDP writer with the PDP reader of a given partipant of type server.
+     * The function is not thread safe (nts) in the sense that it does not take the PDP mutex.
+     * It does however take temp_data_lock_
      */
     void match_pdp_reader_nts_(
-            const eprosima::fastdds::rtps::RemoteServerAttributes& server_att);
+            const fastdds::rtps::ParticipantProxyData& pdata);
 
     /**
      * Release a change from the history of the PDP writer.
@@ -382,11 +371,6 @@ class PDPServer : public fastdds::rtps::PDP
      */
     DServerRoutineEvent* routine_;
 
-    /**
-     * TimedEvent for server ping to other servers
-     */
-    DServerPingEvent* ping_;
-
     //! Discovery database
     fastdds::rtps::ddb::DiscoveryDataBase discovery_db_;
 
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp b/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
index d9950664818..3094a8e712e 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
@@ -146,11 +146,13 @@ void PDPServerListener::on_new_cache_change_added(
                 return;
             }
 
-            auto ret = check_server_discovery_conditions(participant_data);
+            std::string participant_type_str;
+            auto ret = check_server_discovery_conditions(participant_data, participant_type_str);
             if (!ret.first)
             {
                 return;
             }
+            EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, "Participant type " << participant_type_str);
             bool is_client = ret.second;
 
             const auto& pattr = pdp_server()->getRTPSParticipant()->getAttributes();
@@ -170,7 +172,11 @@ void PDPServerListener::on_new_cache_change_added(
             // If the instance handle is different from the writer GUID, then the change has been relayed
             if (iHandle2GUID(change->instanceHandle).guidPrefix != change->writerGUID.guidPrefix)
             {
-                is_local = false;
+                // Servers are always local because we are connected to them in a mesh topology
+                if (participant_type_str != ParticipantType::SERVER && participant_type_str != ParticipantType::BACKUP)
+                {
+                    is_local = false;
+                }
             }
             else
             {
@@ -186,7 +192,8 @@ void PDPServerListener::on_new_cache_change_added(
                             ddb::DiscoveryParticipantChangeData(
                                 participant_data.metatraffic_locators,
                                 is_client,
-                                is_local)))
+                                is_local,
+                                participant_type_str == ParticipantType::SUPER_CLIENT)))
                 {
                     // Remove change from PDP reader history, but do not return it to the pool. From here on, the discovery
                     // database takes ownership of the CacheChange_t. Henceforth there are no references to the change.
@@ -248,13 +255,13 @@ void PDPServerListener::on_new_cache_change_added(
                 lock.unlock();
 
                 // All local builtins are connected, the database will avoid any EDP DATA to be send before having PDP
-                // DATA acknowledgement
-                if (pdata && is_local)
+                // DATA acknowledgement. Non-local SERVERs will also be connected
+                if (pdata && (is_local || (!is_client && participant_type_str != ParticipantType::SUPER_CLIENT)))
                 {
                     pdp_server()->assignRemoteEndpoints(pdata);
                 }
             }
-            // Case ParticipantProxyData already exists but was known remotly and now must be local
+            // Case ParticipantProxyData already exists but was known remotely and now must be local
             else if (is_local && !was_local)
             {
                 // Realease PDP mutex
@@ -361,7 +368,8 @@ void PDPServerListener::on_new_cache_change_added(
 }
 
 std::pair<bool, bool> PDPServerListener::check_server_discovery_conditions(
-        ParticipantProxyData& participant_data)
+        const ParticipantProxyData& participant_data,
+        std::string& participant_type_str)
 {
     // is_valid, is_client
     std::pair<bool, bool> ret{true, true};
@@ -411,57 +419,27 @@ std::pair<bool, bool> PDPServerListener::check_server_discovery_conditions(
     /* Check PARTICIPANT_TYPE */
     if (ret.first)
     {
-        auto participant_type = std::find_if(
-            properties.begin(),
-            properties.end(),
-            [](const dds::ParameterProperty_t& property)
-            {
-                return property.first() == dds::parameter_property_participant_type;
-            });
+        participant_type_str = parent_pdp_->check_participant_type(properties);
 
-        if (participant_type != properties.end())
+        if (participant_type_str == ParticipantType::SERVER ||
+                participant_type_str == ParticipantType::BACKUP ||
+                participant_type_str == ParticipantType::SUPER_CLIENT)
         {
-            if (participant_type->second() == ParticipantType::SERVER ||
-                    participant_type->second() == ParticipantType::BACKUP ||
-                    participant_type->second() == ParticipantType::SUPER_CLIENT)
-            {
-                ret.second = false;
-            }
-            else if (participant_type->second() == ParticipantType::SIMPLE)
-            {
-                EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, "Ignoring " << dds::parameter_property_participant_type << ": "
-                                                                 << participant_type->second());
-                ret.first = false;
-            }
-            else if (participant_type->second() != ParticipantType::CLIENT)
-            {
-                EPROSIMA_LOG_ERROR(RTPS_PDP_LISTENER, "Wrong " << dds::parameter_property_participant_type << ": "
-                                                               << participant_type->second());
-                ret.first = false;
-            }
-            EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, "Participant type " << participant_type->second());
+            ret.second = false;
         }
-        else
+        else if (participant_type_str == ParticipantType::SIMPLE)
         {
-            EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, dds::parameter_property_participant_type << " is not set");
-            // Fallback to checking whether participant is a SERVER looking for the persistence GUID
-            auto persistence_guid = std::find_if(
-                properties.begin(),
-                properties.end(),
-                [](const dds::ParameterProperty_t& property)
-                {
-                    return property.first() == dds::parameter_property_persistence_guid;
-                });
-            // The presence of persistence GUID property suggests a SERVER. This assumption is made to keep
-            // backwards compatibility with Discovery Server v1.0. However, any participant that has been configured
-            // as persistent will have this property.
-            if (persistence_guid != properties.end())
-            {
-                ret.second = false;
-            }
-            EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER,
-                    "Participant is client: " << std::boolalpha << ret.second);
+            EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, "Ignoring " << dds::parameter_property_participant_type << ": "
+                                                             << participant_type_str);
+            ret.first = false;
+        }
+        else if (participant_type_str != ParticipantType::CLIENT)
+        {
+            EPROSIMA_LOG_ERROR(RTPS_PDP_LISTENER, "Wrong " << dds::parameter_property_participant_type << ": "
+                                                           << participant_type_str);
+            ret.first = false;
         }
+        EPROSIMA_LOG_INFO(RTPS_PDP_LISTENER, "Participant type " << participant_type_str);
     }
 
     return ret;
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.hpp b/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.hpp
index 3343f4d3130..0940e0dca36 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.hpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.hpp
@@ -64,13 +64,15 @@ class PDPServerListener : public fastdds::rtps::PDPListener
     /**
      * Checks discovery conditions on a discovery server entity.
      * Essentially, it checks for incoming PIDS of remote proxy datas.
-     * @param participant_data Remote participant data to check.
+     * @param [in]  participant_data Remote participant data to check.
+     * @param [out] participant_type_str Type of the remote participant.
      * @return A pair of booleans.
      * The first one indicates if the remote participant data is valid.
      * The second one indicates if the remote participant data is a client.
      */
     std::pair<bool, bool> check_server_discovery_conditions(
-            fastdds::rtps::ParticipantProxyData& participant_data);
+            const fastdds::rtps::ParticipantProxyData& participant_data,
+            std::string& participant_type_str);
 };
 
 
diff --git a/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp b/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
index 706c9042b40..daa4ac39a09 100644
--- a/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
@@ -385,7 +385,7 @@ bool PDPSimple::create_dcps_participant_endpoints()
     if (!m_discovery.initialPeersList.empty())
     {
         auto entry = LocatorSelectorEntry::create_fully_selected_entry(
-            m_discovery.initialPeersList, LocatorList_t());
+            m_discovery.initialPeersList);
         mp_RTPSParticipant->createSenderResources(entry);
     }
 
diff --git a/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp b/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
deleted file mode 100644
index 7d4ed3cb1a3..00000000000
--- a/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2022 Proyectos y Sistemas de Mantenimiento SL (eProsima).
-//
-// Licensed 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.
-
-/**
- * @file ServerAttributes.cpp
- *
- */
-
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
-
-namespace eprosima {
-namespace fastdds {
-namespace rtps {
-
-template<> const char* server_ostream_separators<char>::list_separator = "; ";
-template<> const wchar_t* server_ostream_separators<wchar_t>::list_separator = L"; ";
-
-template<> const char* server_ostream_separators<char>::locator_separator = "|";
-template<> const wchar_t* server_ostream_separators<wchar_t>::locator_separator = L"|";
-
-} /* namespace rtps */
-} /* namespace fastdds */
-} /* namespace eprosima */
diff --git a/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp b/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
index d11d0e35363..2fb2779ca42 100644
--- a/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
@@ -60,14 +60,12 @@ bool DSClientEvent::event()
     // Iterate over remote servers to check for new unmatched servers
     ParticipantProxyData* part_proxy_data;
     eprosima::shared_lock<eprosima::shared_mutex> lock(mp_PDP->mp_builtin->getDiscoveryMutex());
-    for (auto server: mp_PDP->remote_server_attributes())
+
+    for (auto server: mp_PDP->connected_servers())
     {
         std::unique_lock<std::recursive_mutex> pdp_lock(*mp_PDP->getMutex());
         // Get the participant proxy data of the server
         part_proxy_data = mp_PDP->get_participant_proxy_data(server.guidPrefix);
-
-        // If the server is known (meaning the client has a proxy for it), it means that this client has
-        // received the server's DATA(p), which in turn means that the server has received the client's DATA(p)
         if (nullptr != part_proxy_data)
         {
             // Match EDP endpoints with this server if necessary
@@ -76,13 +74,20 @@ bool DSClientEvent::event()
                 mp_EDP->assignRemoteEndpoints(*(part_proxy_data), true);
             }
         }
-        // If the server is not known, we need to run the event again
         else
         {
-            restart = true;
+            EPROSIMA_LOG_ERROR(CLIENT_PDP_THREAD,
+                    "Error while retrieving Participant Proxy Data of a connected server: "
+                    << server.guidPrefix);
         }
     }
 
+    if (mp_PDP->connected_servers().size() < mp_PDP->remote_server_locators().size())
+    {
+        // If there are pending servers, we need to run the event again
+        restart = true;
+    }
+
     // If we are still not connected to all servers, we need to keep pinging the unmatched ones
     if (restart)
     {
diff --git a/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp b/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
index 2ed27e6b299..be796e85b68 100644
--- a/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
+++ b/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
@@ -61,41 +61,6 @@ bool DServerRoutineEvent::server_routine_event()
     return pending_work;
 }
 
-DServerPingEvent::DServerPingEvent(
-        PDPServer* pdp,
-        double interval)
-    : TimedEvent(pdp->getRTPSParticipant()->getEventResource(),
-            [this]()
-            {
-                return server_ping_event();
-            }, interval)
-    , pdp_(pdp)
-{
-
-}
-
-DServerPingEvent::~DServerPingEvent()
-{
-}
-
-bool DServerPingEvent::server_ping_event()
-{
-    // Check if all servers received my discovery data
-    if (!pdp_->all_servers_acknowledge_pdp())
-    {
-        // Not all servers have yet received our DATA(p) thus resend
-        pdp_->ping_remote_servers();
-        EPROSIMA_LOG_INFO(SERVER_PING_THREAD,
-                "Server " << pdp_->getRTPSParticipant()->getGuid() << " PDP announcement");
-
-        // restart
-        return true;
-    }
-
-    // do not restart
-    return false;
-}
-
 } // namespace rtps
 } // namespace fastdds
 } // namespace eprosima
diff --git a/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.hpp b/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.hpp
index 5b3b91507a6..7a48b03fe0a 100644
--- a/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.hpp
+++ b/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.hpp
@@ -60,29 +60,6 @@ class DServerRoutineEvent : public TimedEvent
     double server_routine_period_;
 };
 
-class DServerPingEvent : public TimedEvent
-{
-public:
-
-    /**
-     * Constructor.
-     * @param pdp Pointer to the PDPServer.
-     * @param interval Interval in ms.
-     */
-    DServerPingEvent(
-            PDPServer* pdp,
-            double interval);
-    ~DServerPingEvent();
-
-    /**
-     * Method invoked when the server routine event occurs.
-     */
-    bool server_ping_event();
-
-    //!Pointer to the PDPServer object.
-    PDPServer* pdp_;
-};
-
 } // namespace rtps
 } // namespace fastdds
 } // namespace eprosima
diff --git a/src/cpp/rtps/network/NetworkFactory.cpp b/src/cpp/rtps/network/NetworkFactory.cpp
index fe1c9ce0674..6102d017b4f 100644
--- a/src/cpp/rtps/network/NetworkFactory.cpp
+++ b/src/cpp/rtps/network/NetworkFactory.cpp
@@ -529,7 +529,7 @@ void NetworkFactory::update_network_interfaces()
 void NetworkFactory::remove_participant_associated_send_resources(
         SendResourceList& send_resource_list,
         const LocatorList_t& remote_participant_locators,
-        const LocatorList_t& participant_initial_peers) const
+        const LocatorList_t& participant_initial_peers_and_ds) const
 {
     // TODO(eduponz): Call the overload of CloseOutputChannel that takes a LocatorSelectorEntry for
     // all transports and let them decide what to do.
@@ -541,7 +541,7 @@ void NetworkFactory::remove_participant_associated_send_resources(
             tcp_transport->cleanup_sender_resources(
                 send_resource_list,
                 remote_participant_locators,
-                participant_initial_peers);
+                participant_initial_peers_and_ds);
         }
     }
 }
diff --git a/src/cpp/rtps/network/NetworkFactory.h b/src/cpp/rtps/network/NetworkFactory.h
index 7288a8ef90e..34e9a592809 100644
--- a/src/cpp/rtps/network/NetworkFactory.h
+++ b/src/cpp/rtps/network/NetworkFactory.h
@@ -308,12 +308,13 @@ class NetworkFactory
      *
      * @param send_resource_list List of send resources associated to the local participant.
      * @param remote_participant_locators List of locators associated to the remote participant.
-     * @param participant_initial_peers List of locators of the initial peers of the local participant.
+     * @param participant_initial_peers_and_ds List of locators of the initial peers and direct servers
+     * of the local participant.
      */
     void remove_participant_associated_send_resources(
             fastdds::rtps::SendResourceList& send_resource_list,
             const LocatorList_t& remote_participant_locators,
-            const LocatorList_t& participant_initial_peers) const;
+            const LocatorList_t& participant_initial_peers_and_ds) const;
 
     /**
      * Returns transports' netmask filter information (transport's netmask filter kind and allowlist).
diff --git a/src/cpp/rtps/participant/RTPSParticipantImpl.cpp b/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
index 0b29d33ac7e..e8d4219776e 100644
--- a/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
+++ b/src/cpp/rtps/participant/RTPSParticipantImpl.cpp
@@ -30,7 +30,6 @@
 #include <fastdds/dds/log/Log.hpp>
 #include <fastdds/LibrarySettings.hpp>
 #include <fastdds/rtps/attributes/BuiltinTransports.hpp>
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
 #include <fastdds/rtps/builtin/data/ParticipantProxyData.hpp>
 #include <fastdds/rtps/common/EntityId_t.hpp>
 #include <fastdds/rtps/common/LocatorList.hpp>
@@ -44,6 +43,7 @@
 #include <fastdds/rtps/transport/UDPv4TransportDescriptor.hpp>
 #include <fastdds/utils/IPFinder.hpp>
 
+#include <rtps/attributes/ServerAttributes.hpp>
 #include <rtps/builtin/BuiltinProtocols.h>
 #include <rtps/builtin/discovery/endpoint/EDP.h>
 #include <rtps/builtin/discovery/participant/PDP.h>
@@ -279,15 +279,78 @@ RTPSParticipantImpl::RTPSParticipantImpl(
         return;
     }
 
+    mp_userParticipant->mp_impl = this;
+
+    setup_guids(persistence_guid);
+
+    if (!setup_transports())
+    {
+        return;
+    }
+
+    setup_timed_events();
+
+#if HAVE_SECURITY
+    // Start security
+    if (!m_security_manager.init(security_attributes_, m_att.properties))
+    {
+        // Participant will be deleted, no need to allocate buffers or create builtin endpoints
+        return;
+    }
+#endif // if HAVE_SECURITY
+
+    setup_meta_traffic();
+    setup_user_traffic();
+    setup_initial_peers();
+    setup_output_traffic();
+
+#if HAVE_SECURITY
+    if (m_security_manager.is_security_active())
+    {
+        if (!m_security_manager.create_entities())
+        {
+            return;
+        }
+    }
+#endif // if HAVE_SECURITY
+
+    // Initialize builtin protocols
+    if (!setup_builtin_protocols())
+    {
+        return;
+    }
+
     if (c_GuidPrefix_Unknown != persistence_guid)
     {
-        m_persistence_guid = GUID_t(persistence_guid, c_EntityId_RTPSParticipant);
+        EPROSIMA_LOG_INFO(RTPS_PARTICIPANT,
+                "RTPSParticipant \"" << m_att.getName() << "\" with guidPrefix: " << m_guid.guidPrefix
+                                     << " and persistence guid: " << persistence_guid);
+    }
+    else
+    {
+        EPROSIMA_LOG_INFO(RTPS_PARTICIPANT,
+                "RTPSParticipant \"" << m_att.getName() << "\" with guidPrefix: " << m_guid.guidPrefix);
     }
 
-    // Setup builtin transports
-    if (m_att.useBuiltinTransports)
+    initialized_ = true;
+}
+
+RTPSParticipantImpl::RTPSParticipantImpl(
+        uint32_t domain_id,
+        const RTPSParticipantAttributes& PParam,
+        const GuidPrefix_t& guidP,
+        RTPSParticipant* par,
+        RTPSParticipantListener* plisten)
+    : RTPSParticipantImpl(domain_id, PParam, guidP, c_GuidPrefix_Unknown, par, plisten)
+{
+}
+
+void RTPSParticipantImpl::setup_guids(
+        const GuidPrefix_t& persistence_guid)
+{
+    if (c_GuidPrefix_Unknown != persistence_guid)
     {
-        set_builtin_transports_from_env_var(m_att);
+        m_persistence_guid = GUID_t(persistence_guid, c_EntityId_RTPSParticipant);
     }
 
     // BACKUP servers guid is its persistence one
@@ -300,6 +363,15 @@ RTPSParticipantImpl::RTPSParticipantImpl(
     std::stringstream guid_sstr;
     guid_sstr << m_guid;
     guid_str_ = guid_sstr.str();
+}
+
+bool RTPSParticipantImpl::setup_transports()
+{
+    // Setup builtin transports
+    if (m_att.useBuiltinTransports)
+    {
+        set_builtin_transports_from_env_var(m_att);
+    }
 
     // Client-server discovery protocol requires that every TCP transport has a listening port
     switch (m_att.builtin.discovery_config.discoveryProtocol)
@@ -317,7 +389,7 @@ RTPSParticipantImpl::RTPSParticipantImpl(
                         EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT,
                                 "Participant " << m_att.getName() << " with GUID " << m_guid <<
                                 " tries to create a TCP server for discovery server without providing a proper listening port.");
-                        break;
+                        return false;
                     }
                     if (!m_att.builtin.metatrafficUnicastLocatorList.empty())
                     {
@@ -334,21 +406,18 @@ RTPSParticipantImpl::RTPSParticipantImpl(
                                     }
                                 });
                     }
-                    for (fastdds::rtps::RemoteServerAttributes& it : m_att.builtin.discovery_config.m_DiscoveryServers)
-                    {
-                        std::for_each(it.metatrafficUnicastLocatorList.begin(),
-                                it.metatrafficUnicastLocatorList.end(), [&](Locator_t& locator)
+                    std::for_each(m_att.builtin.discovery_config.m_DiscoveryServers.begin(),
+                            m_att.builtin.discovery_config.m_DiscoveryServers.end(), [&](Locator_t& locator)
+                            {
+                                // TCP DS default logical port is the same as the physical one
+                                if (locator.kind == LOCATOR_KIND_TCPv4 || locator.kind == LOCATOR_KIND_TCPv6)
                                 {
-                                    // TCP DS default logical port is the same as the physical one
-                                    if (locator.kind == LOCATOR_KIND_TCPv4 || locator.kind == LOCATOR_KIND_TCPv6)
+                                    if (IPLocator::getLogicalPort(locator) == 0)
                                     {
-                                        if (IPLocator::getLogicalPort(locator) == 0)
-                                        {
-                                            IPLocator::setLogicalPort(locator, IPLocator::getPhysicalPort(locator));
-                                        }
+                                        IPLocator::setLogicalPort(locator, IPLocator::getPhysicalPort(locator));
                                     }
-                                });
-                    }
+                                }
+                            });
                 }
             }
             break;
@@ -367,21 +436,18 @@ RTPSParticipantImpl::RTPSParticipantImpl(
                                 " tries to create a TCP client for discovery server without providing a proper listening port." <<
                                 " No TCP participants will be able to connect to this participant, but it will be able make connections.");
                     }
-                    for (fastdds::rtps::RemoteServerAttributes& it : m_att.builtin.discovery_config.m_DiscoveryServers)
-                    {
-                        std::for_each(it.metatrafficUnicastLocatorList.begin(),
-                                it.metatrafficUnicastLocatorList.end(), [&](Locator_t& locator)
+                    std::for_each(m_att.builtin.discovery_config.m_DiscoveryServers.begin(),
+                            m_att.builtin.discovery_config.m_DiscoveryServers.end(), [&](Locator_t& locator)
+                            {
+                                // TCP DS default logical port is the same as the physical one
+                                if (locator.kind == LOCATOR_KIND_TCPv4 || locator.kind == LOCATOR_KIND_TCPv6)
                                 {
-                                    // TCP DS default logical port is the same as the physical one
-                                    if (locator.kind == LOCATOR_KIND_TCPv4 || locator.kind == LOCATOR_KIND_TCPv6)
+                                    if (IPLocator::getLogicalPort(locator) == 0)
                                     {
-                                        if (IPLocator::getLogicalPort(locator) == 0)
-                                        {
-                                            IPLocator::setLogicalPort(locator, IPLocator::getPhysicalPort(locator));
-                                        }
+                                        IPLocator::setLogicalPort(locator, IPLocator::getPhysicalPort(locator));
                                     }
-                                });
-                    }
+                                }
+                            });
                 }
             }
         default:
@@ -448,14 +514,9 @@ RTPSParticipantImpl::RTPSParticipantImpl(
         }
     }
 
-    mp_userParticipant->mp_impl = this;
-    uint32_t id_for_thread = static_cast<uint32_t>(m_att.participantID);
-    const fastdds::rtps::ThreadSettings& thr_config = m_att.timed_events_thread;
-    mp_event_thr.init_thread(thr_config, "dds.ev.%u", id_for_thread);
-
     if (!networkFactoryHasRegisteredTransports())
     {
-        return;
+        return false;
     }
 
     // Check netmask filtering preconditions
@@ -472,71 +533,21 @@ RTPSParticipantImpl::RTPSParticipantImpl(
             m_att.default_external_unicast_locators, error_msg))
     {
         EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT, error_msg);
-        return;
-    }
-
-#if HAVE_SECURITY
-    // Start security
-    if (!m_security_manager.init(
-                security_attributes_,
-                m_att.properties))
-    {
-        // Participant will be deleted, no need to allocate buffers or create builtin endpoints
-        return;
-    }
-#endif // if HAVE_SECURITY
-
-    setup_meta_traffic();
-    setup_user_traffic();
-    setup_initial_peers();
-    setup_output_traffic();
-
-#if HAVE_SECURITY
-    if (m_security_manager.is_security_active())
-    {
-        if (!m_security_manager.create_entities())
-        {
-            return;
-        }
+        return false;
     }
-#endif // if HAVE_SECURITY
 
     // Copy NetworkFactory network_configuration to participant attributes prior to proxy creation
     // NOTE: all transports already registered before
     m_att.builtin.network_configuration = m_network_Factory.network_configuration();
 
-    mp_builtinProtocols = new BuiltinProtocols();
-
-    // Initialize builtin protocols
-    if (!mp_builtinProtocols->initBuiltinProtocols(this, m_att.builtin))
-    {
-        EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT, "The builtin protocols were not correctly initialized");
-        return;
-    }
-
-    if (c_GuidPrefix_Unknown != persistence_guid)
-    {
-        EPROSIMA_LOG_INFO(RTPS_PARTICIPANT,
-                "RTPSParticipant \"" << m_att.getName() << "\" with guidPrefix: " << m_guid.guidPrefix
-                                     << " and persistence guid: " << persistence_guid);
-    }
-    else
-    {
-        EPROSIMA_LOG_INFO(RTPS_PARTICIPANT,
-                "RTPSParticipant \"" << m_att.getName() << "\" with guidPrefix: " << m_guid.guidPrefix);
-    }
-
-    initialized_ = true;
+    return true;
 }
 
-RTPSParticipantImpl::RTPSParticipantImpl(
-        uint32_t domain_id,
-        const RTPSParticipantAttributes& PParam,
-        const GuidPrefix_t& guidP,
-        RTPSParticipant* par,
-        RTPSParticipantListener* plisten)
-    : RTPSParticipantImpl(domain_id, PParam, guidP, c_GuidPrefix_Unknown, par, plisten)
+void RTPSParticipantImpl::setup_timed_events()
 {
+    uint32_t id_for_thread = static_cast<uint32_t>(m_att.participantID);
+    const fastdds::rtps::ThreadSettings& thr_config = m_att.timed_events_thread;
+    mp_event_thr.init_thread(thr_config, "dds.ev.%u", id_for_thread);
 }
 
 void RTPSParticipantImpl::setup_meta_traffic()
@@ -717,6 +728,18 @@ void RTPSParticipantImpl::setup_output_traffic()
     }
 }
 
+bool RTPSParticipantImpl::setup_builtin_protocols()
+{
+    mp_builtinProtocols = new BuiltinProtocols();
+    if (!mp_builtinProtocols->initBuiltinProtocols(this, m_att.builtin))
+    {
+        EPROSIMA_LOG_ERROR(RTPS_PARTICIPANT, "The builtin protocols were not correctly initialized");
+        return false;
+    }
+
+    return true;
+}
+
 void RTPSParticipantImpl::enable()
 {
     mp_builtinProtocols->enable();
@@ -1455,30 +1478,24 @@ void RTPSParticipantImpl::update_attributes(
     bool update_pdp = false;
 
     // Check if discovery servers need to be updated
-    eprosima::fastdds::rtps::RemoteServerList_t converted_discovery_servers =
+    eprosima::fastdds::rtps::LocatorList_t converted_discovery_servers =
             patt.builtin.discovery_config.m_DiscoveryServers;
-    if (patt.builtin.discovery_config.m_DiscoveryServers != m_att.builtin.discovery_config.m_DiscoveryServers)
+    if (converted_discovery_servers != m_att.builtin.discovery_config.m_DiscoveryServers)
     {
         for (auto& transportDescriptor : m_att.userTransports)
         {
             TCPTransportDescriptor* pT = dynamic_cast<TCPTransportDescriptor*>(transportDescriptor.get());
             if (pT)
             {
-                for (fastdds::rtps::RemoteServerAttributes& it : converted_discovery_servers)
-                {
-                    std::for_each(it.metatrafficUnicastLocatorList.begin(),
-                            it.metatrafficUnicastLocatorList.end(), [&](Locator_t& locator)
+                // TCP DS default logical port is the same as the physical one
+                std::for_each(converted_discovery_servers.begin(),
+                        converted_discovery_servers.end(), [&](Locator_t& locator)
+                        {
+                            if (IPLocator::getLogicalPort(locator) == 0)
                             {
-                                // TCP DS default logical port is the same as the physical one
-                                if (locator.kind == LOCATOR_KIND_TCPv4 || locator.kind == LOCATOR_KIND_TCPv6)
-                                {
-                                    if (IPLocator::getLogicalPort(locator) == 0)
-                                    {
-                                        IPLocator::setLogicalPort(locator, IPLocator::getPhysicalPort(locator));
-                                    }
-                                }
-                            });
-                }
+                                IPLocator::setLogicalPort(locator, IPLocator::getPhysicalPort(locator));
+                            }
+                        });
             }
         }
     }
@@ -1489,8 +1506,6 @@ void RTPSParticipantImpl::update_attributes(
             || local_interfaces_changed)
     {
         update_pdp = true;
-        std::vector<GUID_t> modified_servers;
-        LocatorList_t modified_locators;
 
         // Update RTPSParticipantAttributes members
         m_att.userData = patt.userData;
@@ -1516,47 +1531,6 @@ void RTPSParticipantImpl::update_attributes(
             }
         }
 
-        // Check that the remote servers list is consistent: all the already known remote servers must be included in
-        // the list and either new remote servers are added or remote server listening locator is modified.
-        for (auto existing_server : m_att.builtin.discovery_config.m_DiscoveryServers)
-        {
-            bool contained = false;
-            for (auto incoming_server : converted_discovery_servers)
-            {
-                if (existing_server.guidPrefix == incoming_server.guidPrefix)
-                {
-                    for (auto incoming_locator : incoming_server.metatrafficUnicastLocatorList)
-                    {
-                        bool locator_contained = false;
-                        for (auto existing_locator : existing_server.metatrafficUnicastLocatorList)
-                        {
-                            if (incoming_locator == existing_locator)
-                            {
-                                locator_contained = true;
-                                break;
-                            }
-                        }
-                        if (!locator_contained)
-                        {
-                            modified_servers.emplace_back(incoming_server.GetParticipant());
-                            modified_locators.push_back(incoming_locator);
-                            EPROSIMA_LOG_INFO(RTPS_QOS_CHECK,
-                                    "DS Server: " << incoming_server.guidPrefix << " has modified its locators: "
-                                                  << incoming_locator << " being added");
-                        }
-                    }
-                    contained = true;
-                    break;
-                }
-            }
-            if (!contained)
-            {
-                EPROSIMA_LOG_ERROR(RTPS_QOS_CHECK,
-                        "Discovery Servers cannot be removed from the list; they can only be added");
-                return;
-            }
-        }
-
         {
             std::lock_guard<std::recursive_mutex> lock(*pdp->getMutex());
 
@@ -1586,10 +1560,6 @@ void RTPSParticipantImpl::update_attributes(
                 createSenderResources(m_att.builtin.metatrafficUnicastLocatorList);
                 createSenderResources(m_att.defaultUnicastLocatorList);
             }
-            if (!modified_locators.empty())
-            {
-                createSenderResources(modified_locators);
-            }
 
             // Update remote servers list
             if (m_att.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::CLIENT ||
@@ -1597,33 +1567,11 @@ void RTPSParticipantImpl::update_attributes(
                     m_att.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::SERVER ||
                     m_att.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::BACKUP)
             {
-                // Add incoming servers if we don't know about them already or the listening locator has been modified
-                for (auto incoming_server : converted_discovery_servers)
-                {
-                    eprosima::fastdds::rtps::RemoteServerList_t::iterator server_it;
-                    for (server_it = m_att.builtin.discovery_config.m_DiscoveryServers.begin();
-                            server_it != m_att.builtin.discovery_config.m_DiscoveryServers.end(); server_it++)
-                    {
-                        if (server_it->guidPrefix == incoming_server.guidPrefix)
-                        {
-                            // Check if the listening locators have been modified
-                            for (auto guid : modified_servers)
-                            {
-                                if (guid == incoming_server.GetParticipant())
-                                {
-                                    server_it->metatrafficUnicastLocatorList =
-                                            incoming_server.metatrafficUnicastLocatorList;
-                                    break;
-                                }
-                            }
-                            break;
-                        }
-                    }
-                    if (server_it == m_att.builtin.discovery_config.m_DiscoveryServers.end())
-                    {
-                        m_att.builtin.discovery_config.m_DiscoveryServers.push_back(incoming_server);
-                    }
-                }
+                // Update list of Discovery Servers. The participant will remain connected to the servers of the
+                // previous list but will cease pinging servers that are not included in the new list.
+                // Liveliness will be maintained until the old server is removed from the participant, ensuring
+                // that existing connections are unaffected by the list update.
+                m_att.builtin.discovery_config.m_DiscoveryServers = converted_discovery_servers;
 
                 // Update the servers list in builtin protocols
                 {
@@ -1637,11 +1585,6 @@ void RTPSParticipantImpl::update_attributes(
                 {
                     fastdds::rtps::PDPServer* pdp_server = static_cast<fastdds::rtps::PDPServer*>(pdp);
                     pdp_server->update_remote_servers_list();
-                    for (auto remote_server : modified_servers)
-                    {
-                        pdp_server->remove_remote_participant(remote_server,
-                                ParticipantDiscoveryInfo::DISCOVERY_STATUS::DROPPED_PARTICIPANT);
-                    }
                 }
                 // Notify PDPClient
                 else if (m_att.builtin.discovery_config.discoveryProtocol == DiscoveryProtocol::CLIENT ||
@@ -1649,11 +1592,6 @@ void RTPSParticipantImpl::update_attributes(
                 {
                     fastdds::rtps::PDPClient* pdp_client = static_cast<fastdds::rtps::PDPClient*>(pdp);
                     pdp_client->update_remote_servers_list();
-                    for (auto remote_server : modified_servers)
-                    {
-                        pdp_client->remove_remote_participant(remote_server,
-                                ParticipantDiscoveryInfo::DISCOVERY_STATUS::DROPPED_PARTICIPANT);
-                    }
                 }
             }
         }
@@ -2783,19 +2721,6 @@ bool RTPSParticipantImpl::ignore_participant(
         EPROSIMA_LOG_WARNING(RTPS_PARTICIPANT, "A participant is unable to ignore itself");
         return false;
     }
-    {
-        shared_lock<eprosima::shared_mutex> _(mp_builtinProtocols->getDiscoveryMutex());
-
-        for (auto server_it = m_att.builtin.discovery_config.m_DiscoveryServers.begin();
-                server_it != m_att.builtin.discovery_config.m_DiscoveryServers.end(); server_it++)
-        {
-            if (server_it->guidPrefix == participant_guid)
-            {
-                EPROSIMA_LOG_WARNING(RTPS_PARTICIPANT, "Cannot ignore one of this participant Discovery Servers");
-                return false;
-            }
-        }
-    }
     {
         std::unique_lock<shared_mutex> _(ignored_mtx_);
         ignored_participants_.insert(participant_guid);
@@ -3196,10 +3121,15 @@ void RTPSParticipantImpl::update_removed_participant(
     if (!remote_participant_locators.empty())
     {
         std::lock_guard<std::timed_mutex> guard(m_send_resources_mutex_);
+        LocatorList_t initial_peers_and_ds = m_att.builtin.discovery_config.m_DiscoveryServers;
+        for (const Locator_t& locator : m_att.builtin.initialPeersList)
+        {
+            initial_peers_and_ds.push_back(locator);
+        }
         m_network_Factory.remove_participant_associated_send_resources(
             send_resource_list_,
             remote_participant_locators,
-            m_att.builtin.initialPeersList);
+            initial_peers_and_ds);
     }
 }
 
diff --git a/src/cpp/rtps/participant/RTPSParticipantImpl.h b/src/cpp/rtps/participant/RTPSParticipantImpl.h
index e9a9ea3acfe..d9f913300b9 100644
--- a/src/cpp/rtps/participant/RTPSParticipantImpl.h
+++ b/src/cpp/rtps/participant/RTPSParticipantImpl.h
@@ -638,10 +638,15 @@ class RTPSParticipantImpl
     //! Protect ignored entities collection concurrent access
     mutable shared_mutex ignored_mtx_;
 
+    void setup_guids(
+            const GuidPrefix_t& persistence_guid);
+    bool setup_transports();
+    void setup_timed_events();
     void setup_meta_traffic();
     void setup_user_traffic();
     void setup_initial_peers();
     void setup_output_traffic();
+    bool setup_builtin_protocols();
 
     RTPSParticipantImpl& operator =(
             const RTPSParticipantImpl&) = delete;
diff --git a/src/cpp/rtps/transport/TCPTransportInterface.cpp b/src/cpp/rtps/transport/TCPTransportInterface.cpp
index 1500cec0af1..907e9ed15c6 100644
--- a/src/cpp/rtps/transport/TCPTransportInterface.cpp
+++ b/src/cpp/rtps/transport/TCPTransportInterface.cpp
@@ -2013,7 +2013,7 @@ void TCPTransportInterface::fill_local_physical_port(
 void TCPTransportInterface::cleanup_sender_resources(
         SendResourceList& send_resource_list,
         const LocatorList& remote_participant_locators,
-        const LocatorList& participant_initial_peers) const
+        const LocatorList& participant_initial_peers_and_ds) const
 {
     // Since send resources handle physical locators, we need to convert the remote participant locators to physical
     std::set<Locator> remote_participant_physical_locators;
@@ -2030,8 +2030,8 @@ void TCPTransportInterface::cleanup_sender_resources(
         }
     }
 
-    // Exlude initial peers.
-    for (const auto& initial_peer : participant_initial_peers)
+    // Exclude initial peers.
+    for (const auto& initial_peer : participant_initial_peers_and_ds)
     {
         if (std::find(remote_participant_physical_locators.begin(), remote_participant_physical_locators.end(),
                 IPLocator::toPhysicalLocator(initial_peer)) != remote_participant_physical_locators.end())
diff --git a/src/cpp/rtps/transport/TCPTransportInterface.h b/src/cpp/rtps/transport/TCPTransportInterface.h
index 1b291a1ea7d..972ab96bc70 100644
--- a/src/cpp/rtps/transport/TCPTransportInterface.h
+++ b/src/cpp/rtps/transport/TCPTransportInterface.h
@@ -510,12 +510,13 @@ class TCPTransportInterface : public TransportInterface
      *
      * @param send_resource_list List of send resources associated to the local participant.
      * @param remote_participant_locators Set of locators associated to the remote participant.
-     * @param participant_initial_peers List of locators associated to the initial peers of the local participant.
+     * @param participant_initial_peers_and_ds List of locators associated to the initial peers and direct servers
+     * of the local participant.
      */
     void cleanup_sender_resources(
             SendResourceList& send_resource_list,
             const LocatorList& remote_participant_locators,
-            const LocatorList& participant_initial_peers) const;
+            const LocatorList& participant_initial_peers_and_ds) const;
 
     /**
      * Method to add the logical ports associated to a channel that was not available
diff --git a/src/cpp/rtps/writer/StatefulWriter.cpp b/src/cpp/rtps/writer/StatefulWriter.cpp
index aa674715998..717fc92568e 100644
--- a/src/cpp/rtps/writer/StatefulWriter.cpp
+++ b/src/cpp/rtps/writer/StatefulWriter.cpp
@@ -349,18 +349,18 @@ void StatefulWriter::unsent_change_added_to_history(
                 [this, &should_be_sent, &change, &max_blocking_time](ReaderProxy* reader)
                 {
                     ChangeForReader_t changeForReader(change);
-                    bool is_revelant = reader->rtps_is_relevant(change);
+                    bool is_relevant = reader->rtps_is_relevant(change);
 
                     if (m_pushMode || !reader->is_reliable() || reader->is_local_reader())
                     {
                         //ChangeForReader_t construct sets status to UNSENT.
-                        should_be_sent |= is_revelant;
+                        should_be_sent |= is_relevant;
                     }
                     else
                     {
                         changeForReader.setStatus(UNACKNOWLEDGED);
                     }
-                    reader->add_change(changeForReader, is_revelant, false, max_blocking_time);
+                    reader->add_change(changeForReader, is_relevant, false, max_blocking_time);
 
                     return false;
                 }
diff --git a/src/cpp/xmlparser/XMLElementParser.cpp b/src/cpp/xmlparser/XMLElementParser.cpp
index d4d8df13c3c..a23ce949f6d 100644
--- a/src/cpp/xmlparser/XMLElementParser.cpp
+++ b/src/cpp/xmlparser/XMLElementParser.cpp
@@ -538,8 +538,8 @@ XMLP_ret XMLParser::getXMLDiscoverySettings(
         }
         else if (strcmp(name, SERVER_LIST) == 0)
         {
-            // discoverServersList - DiscoveryServerList
-            if (XMLP_ret::XML_OK != getXMLList(p_aux0, settings.m_DiscoveryServers, ident))
+            // discoverServersList - locatorListType
+            if (XMLP_ret::XML_OK != getXMLLocatorList(p_aux0, settings.m_DiscoveryServers, ident))
             {
                 return XMLP_ret::XML_ERROR;
             }
@@ -4030,109 +4030,6 @@ XMLP_ret XMLParser::getXMLEnum(
     return XMLP_ret::XML_OK;
 }
 
-XMLP_ret XMLParser::getXMLRemoteServer(
-        tinyxml2::XMLElement* elem,
-        eprosima::fastdds::rtps::RemoteServerAttributes& server,
-        uint8_t ident)
-{
-    /*
-        <xs:complexType name="RemoteServerAttributes">
-            <xs:all minOccurs="1">
-                <xs:element name="metatrafficUnicastLocatorList" type="locatorListType" minOccurs="0"/>
-                <xs:element name="metatrafficMulticastLocatorList" type="locatorListType" minOccurs="0"/>
-            </xs:all>
-            <xs:attribute name="guidPrefix" type="guid" use="required"/>
-        </xs:complexType>
-     */
-
-    const char* Prefix = nullptr;
-    tinyxml2::XMLElement* pLU = nullptr, * pLM = nullptr;
-
-    if (nullptr == elem )
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLRemoteServer XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-    else if (nullptr == (Prefix = elem->Attribute(PREFIX)))
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLRemoteServer try to recover server's guidPrefix XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-    else if (!server.ReadguidPrefix(Prefix))
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER, "getXMLRemoteServer found an invalid server's guidPrefix XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-
-    pLU = elem->FirstChildElement(META_UNI_LOC_LIST);
-    pLM = elem->FirstChildElement(META_MULTI_LOC_LIST);
-
-    if ( pLU == nullptr && pLM == nullptr )
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER, "getXMLRemoteServer couldn't find any server's locator XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-
-    if (pLU && XMLP_ret::XML_OK != getXMLLocatorList(pLU, server.metatrafficUnicastLocatorList, ident))
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER,
-                "getXMLRemoteServer was given a misformatted server's " << META_UNI_LOC_LIST << " XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-
-    if (pLM && XMLP_ret::XML_OK != getXMLLocatorList(pLM, server.metatrafficMulticastLocatorList, ident))
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER,
-                "getXMLRemoteServer was given a misformatted server's " << META_MULTI_LOC_LIST << " XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-
-    return XMLP_ret::XML_OK;
-}
-
-XMLP_ret XMLParser::getXMLList(
-        tinyxml2::XMLElement* elem,
-        eprosima::fastdds::rtps::RemoteServerList_t& list,
-        uint8_t ident)
-{
-    /*
-        <xs:complexType name="DiscoveryServerList">
-            <xs:sequence>
-                <xs:element name="RemoteServer" type="RemoteServerAttributes" minOccurs="0" maxOccurs="unbounded"/>
-            </xs:sequence>
-        </xs:complexType>
-     */
-
-    tinyxml2::XMLElement* pS = nullptr;
-
-    if (nullptr == elem)
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER, "nullptr when getXMLList XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-    else if (nullptr == (pS = elem->FirstChildElement(RSERVER)))
-    {
-        EPROSIMA_LOG_ERROR(XMLPARSER, "getXMLList couldn't find any RemoteServer XML_ERROR!");
-        return XMLP_ret::XML_ERROR;
-    }
-
-    while (pS)
-    {
-        eprosima::fastdds::rtps::RemoteServerAttributes server;
-        if (XMLP_ret::XML_OK != getXMLRemoteServer(pS, server, ident))
-        {
-            EPROSIMA_LOG_ERROR(XMLPARSER, "getXMLList was given a misformatted RemoteServer XML_ERROR!");
-            return XMLP_ret::XML_ERROR;
-        }
-        list.push_back(std::move(server));
-
-        pS = pS->NextSiblingElement(RSERVER);
-    }
-
-    return XMLP_ret::XML_OK;
-
-}
-
 XMLP_ret XMLParser::getXMLString(
         tinyxml2::XMLElement* elem,
         std::string* s,
diff --git a/src/cpp/xmlparser/XMLParser.h b/src/cpp/xmlparser/XMLParser.h
index 398129476a8..94cb4295eae 100644
--- a/src/cpp/xmlparser/XMLParser.h
+++ b/src/cpp/xmlparser/XMLParser.h
@@ -623,21 +623,11 @@ class XMLParser
             rtps::DiscoveryProtocol* e,
             uint8_t ident);
 
-    static XMLP_ret getXMLList(
-            tinyxml2::XMLElement* elem,
-            eprosima::fastdds::rtps::RemoteServerList_t& list,
-            uint8_t ident);
-
     static XMLP_ret getXMLEnum(
             tinyxml2::XMLElement* elem,
             rtps::ParticipantFilteringFlags* e,
             uint8_t ident);
 
-    static XMLP_ret getXMLRemoteServer(
-            tinyxml2::XMLElement* elem,
-            eprosima::fastdds::rtps::RemoteServerAttributes& server,
-            uint8_t ident);
-
     static XMLP_ret getXMLString(
             tinyxml2::XMLElement* elem,
             std::string* s,
diff --git a/test/blackbox/CMakeLists.txt b/test/blackbox/CMakeLists.txt
index f9c3a7d1754..a420d10bbc1 100644
--- a/test/blackbox/CMakeLists.txt
+++ b/test/blackbox/CMakeLists.txt
@@ -49,11 +49,7 @@ if(NOT LibP11_FOUND)
     set(pkcs_filter "*pkcs*")
 endif() # LibP11_FOUND
 
-if(EPROSIMA_TEST_DNS_NOT_SET_UP)
-    set(dns_filter "*ServerClientEnvironmentSetUpDNS*")
-endif()
-
-string(JOIN ":" BLACKBOX_HIGH_LEVEL_IGNORED_TESTS ${pkcs_filter} ${dns_filter})
+string(JOIN ":" BLACKBOX_HIGH_LEVEL_IGNORED_TESTS ${pkcs_filter})
 if(NOT BLACKBOX_HIGH_LEVEL_IGNORED_TESTS STREQUAL "")
 	message(STATUS "Ignoring tests '${BLACKBOX_HIGH_LEVEL_IGNORED_TESTS}'")
     string(PREPEND BLACKBOX_HIGH_LEVEL_IGNORED_TESTS "-")
@@ -245,5 +241,4 @@ set_property(DIRECTORY APPEND PROPERTY
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/environment_file.json
     ${CMAKE_CURRENT_BINARY_DIR}/environment_file.json COPYONLY)
 
-unset(dns_filter)
 unset(pkcs_filter)
diff --git a/test/blackbox/api/dds-pim/PubSubParticipant.hpp b/test/blackbox/api/dds-pim/PubSubParticipant.hpp
index 6a3eb0cd70e..d204661a326 100644
--- a/test/blackbox/api/dds-pim/PubSubParticipant.hpp
+++ b/test/blackbox/api/dds-pim/PubSubParticipant.hpp
@@ -886,13 +886,11 @@ class PubSubParticipant
 
     PubSubParticipant& fill_server_qos(
             eprosima::fastdds::dds::WireProtocolConfigQos& qos,
-            eprosima::fastdds::rtps::GuidPrefix_t& guid,
             eprosima::fastdds::rtps::Locator_t& locator_server,
             uint16_t port,
             uint32_t kind)
     {
         qos.builtin.discovery_config.discoveryProtocol = eprosima::fastdds::rtps::DiscoveryProtocol::SERVER;
-        qos.prefix = guid;
         // Generate server's listening locator
         eprosima::fastdds::rtps::IPLocator::setIPv4(locator_server, 127, 0, 0, 1);
         eprosima::fastdds::rtps::IPLocator::setPhysicalPort(locator_server, port);
diff --git a/test/blackbox/common/BlackboxTestsDiscovery.cpp b/test/blackbox/common/BlackboxTestsDiscovery.cpp
index dd60905badf..934f64f8090 100644
--- a/test/blackbox/common/BlackboxTestsDiscovery.cpp
+++ b/test/blackbox/common/BlackboxTestsDiscovery.cpp
@@ -28,12 +28,13 @@
 #include <fastdds/dds/domain/DomainParticipantFactory.hpp>
 #include <fastdds/dds/domain/DomainParticipantListener.hpp>
 #include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
 #include <fastdds/rtps/common/CDRMessage_t.hpp>
 #include <fastdds/rtps/messages/RTPS_messages.hpp>
 #include <fastdds/rtps/transport/test_UDPv4TransportDescriptor.hpp>
 #include <fastdds/rtps/transport/UDPv4TransportDescriptor.hpp>
 
+#include <rtps/attributes/ServerAttributes.hpp>
+
 #include "../utils/filter_helpers.hpp"
 #include "BlackboxTests.hpp"
 #include "DatagramInjectionTransport.hpp"
@@ -1386,571 +1387,6 @@ GTEST_INSTANTIATE_TEST_MACRO(Discovery,
 
         });
 
-//! Tests the server-client setup using environment variable works fine
-TEST(Discovery, ServerClientEnvironmentSetUp)
-{
-    using namespace std;
-    using namespace eprosima::fastdds::rtps;
-
-    RemoteServerList_t output, standard;
-    RemoteServerAttributes att;
-    Locator_t loc, loc6(LOCATOR_KIND_UDPv6, 0);
-
-    // We are going to use several test string and check they are properly parsed and turn into RemoteServerList_t
-    // 1. Single server address without specific port provided
-    string text = "192.168.36.34";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc, text);
-    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 2. Single server IPv6 address without specific port provided
-    text = "2a02:26f0:dd:499::356e";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc6, text);
-    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 3. Single server address specifying a custom listening port
-    text = "192.168.36.34:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc, text);
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 4. Single server IPv6 address specifying a custom listening port
-    text = "[2001:470:142:5::116]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc6, "2001:470:142:5::116");
-    IPLocator::setPhysicalPort(loc6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 5. Check any locator is turned into localhost
-    text = "0.0.0.0:14520;[::]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc, "127.0.0.1");
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv6(loc6, "::1");
-    IPLocator::setPhysicalPort(loc6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 6. Check empty string scenario is handled
-    text = "";
-    output.clear();
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_TRUE(output.empty());
-
-    // 7. Check at least one server be present scenario is hadled
-    text = ";;;;";
-    output.clear();
-
-    ASSERT_FALSE(load_environment_server_info(text, output));
-
-    // 8. Check several server scenario
-    text = "192.168.36.34:14520;172.29.55.77:8783;172.30.80.1:31090";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("192.168.36.34"));
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.29.55.77"));
-    IPLocator::setPhysicalPort(loc, 8783);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.30.80.1"));
-    IPLocator::setPhysicalPort(loc, 31090);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(2, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 9. Check several server scenario with IPv6 addresses too
-    text = "192.168.36.34:14520;[2a02:ec80:600:ed1a::3]:8783;172.30.80.1:31090";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, "192.168.36.34");
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv6(loc6, "2a02:ec80:600:ed1a::3");
-    IPLocator::setPhysicalPort(loc6, 8783);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.30.80.1"));
-    IPLocator::setPhysicalPort(loc, 31090);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(2, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 10. Check multicast addresses are identified as such
-    text = "239.255.0.1;ff1e::ffff:efff:1";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, "239.255.0.1");
-    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficMulticastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv6(loc6, "ff1e::ffff:efff:1");
-    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficMulticastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 11. Check ignore some servers scenario
-    text = ";192.168.36.34:14520;;172.29.55.77:8783;172.30.80.1:31090;";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("192.168.36.34"));
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.29.55.77"));
-    IPLocator::setPhysicalPort(loc, 8783);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(3, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.30.80.1"));
-    IPLocator::setPhysicalPort(loc, 31090);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(4, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 12. Check that env var cannot specify more than 256 servers
-    text = ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"
-            ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"
-            ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;192.168.36.34:14520";
-    output.clear();
-
-    ASSERT_FALSE(load_environment_server_info(text, output));
-
-    // 13. Check addresses as dns name (test domain urls are checked on a specific test)
-    text = "localhost:12345";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, "127.0.0.1");
-    IPLocator::setPhysicalPort(loc, 12345);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    IPLocator::setIPv6(loc6, "::1");
-    IPLocator::setPhysicalPort(loc6, 12345);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 14. Check mixed scenario with addresses and dns
-    text = "192.168.36.34:14520;localhost:12345;172.30.80.1:31090;";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("192.168.36.34"));
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("127.0.0.1"));
-    IPLocator::setPhysicalPort(loc, 12345);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    IPLocator::setIPv6(loc6, string("::1"));
-    IPLocator::setPhysicalPort(loc6, 12345);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.30.80.1"));
-    IPLocator::setPhysicalPort(loc, 31090);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(2, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // TCP transport
-
-    Locator_t loc_tcp(LOCATOR_KIND_TCPv4, 0);
-    Locator_t loc_tcp_6(LOCATOR_KIND_TCPv6, 0);
-
-    // 15. Single TCPv4 address without specifying a custom listening port
-
-    text = "TCPv4:[192.168.36.34]";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc_tcp, "192.168.36.34");
-    IPLocator::setPhysicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
-    IPLocator::setLogicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 16. Single TCPv6 address without specifying a custom listening port
-
-    text = "TCPv6:[2a02:26f0:dd:499::356e]";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc_tcp_6, "2a02:26f0:dd:499::356e");
-    IPLocator::setPhysicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
-    IPLocator::setLogicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp_6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 17. Single TCPv4 address specifying a custom listening port
-
-    text = "TCPv4:[192.168.36.34]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc_tcp, "192.168.36.34");
-    IPLocator::setPhysicalPort(loc_tcp, 14520);
-    IPLocator::setLogicalPort(loc_tcp, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 18. Single TCPv6 address specifying a custom listening port
-
-    text = "TCPv6:[2a02:26f0:dd:499::356e]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc_tcp_6, "2a02:26f0:dd:499::356e");
-    IPLocator::setPhysicalPort(loc_tcp_6, 14520);
-    IPLocator::setLogicalPort(loc_tcp_6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp_6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-}
-
-//! Tests the server-client setup using environment variable works fine using DNS
-TEST(Discovery, ServerClientEnvironmentSetUpDNS)
-{
-    using namespace std;
-    using namespace eprosima::fastdds::rtps;
-
-    RemoteServerList_t output, standard;
-    RemoteServerAttributes att;
-    Locator_t loc, loc6(LOCATOR_KIND_UDPv6, 0);
-
-    Locator_t loc_tcp(LOCATOR_KIND_TCPv4, 0);
-    Locator_t loc_tcp_6(LOCATOR_KIND_TCPv6, 0);
-
-    // 1. single server DNS address resolution without specific port provided
-    std::string text = "www.acme.com.test";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    IPLocator::setIPv4(loc, "216.58.215.164");
-    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 2. single server DNS address specifying a custom listening port
-    text = "www.acme.com.test:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    IPLocator::setIPv4(loc, "216.58.215.164");
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 3. single server DNS address specifying a custom locator type
-    // UDPv4
-    text = "UDPv4:[www.acme.com.test]";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc, "216.58.215.164");
-    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // UDPv6
-    text = "UDPv6:[www.acme.com.test]";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // TCPv4
-    text = "TCPv4:[www.acme.com.test]";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc_tcp, "216.58.215.164");
-    IPLocator::setPhysicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
-    IPLocator::setLogicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // TCPv6
-    text = "TCPv6:[www.acme.com.test]";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc_tcp_6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
-    IPLocator::setLogicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp_6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // 4. single server DNS address specifying a custom locator type and listening port
-    // UDPv4
-    text = "UDPv4:[www.acme.com.test]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc, "216.58.215.164");
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // UDPv6
-    text = "UDPv6:[www.acme.com.test]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // TCPv4
-    text = "TCPv4:[www.acme.com.test]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv4(loc_tcp, "216.58.215.164");
-    IPLocator::setPhysicalPort(loc_tcp, 14520);
-    IPLocator::setLogicalPort(loc_tcp, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // TCPv6
-    text = "TCPv6:[www.acme.com.test]:14520";
-
-    att.clear();
-    output.clear();
-    standard.clear();
-    IPLocator::setIPv6(loc_tcp_6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc_tcp_6, 14520);
-    IPLocator::setLogicalPort(loc_tcp_6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc_tcp_6);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-
-    // SHM Locator kind should fail
-    text = "SHM:[www.acme.com.test]";
-
-    output.clear();
-    ASSERT_FALSE(load_environment_server_info(text, output));
-
-    // 5. Check mixed scenario with addresses and dns
-    text = "192.168.36.34:14520;UDPv6:[www.acme.com.test]:14520;172.30.80.1:31090;";
-
-    output.clear();
-    standard.clear();
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("192.168.36.34"));
-    IPLocator::setPhysicalPort(loc, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(0, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
-    IPLocator::setPhysicalPort(loc6, 14520);
-    att.metatrafficUnicastLocatorList.push_back(loc6);
-    get_server_client_default_guidPrefix(1, att.guidPrefix);
-    standard.push_back(att);
-
-    att.clear();
-    IPLocator::setIPv4(loc, string("172.30.80.1"));
-    IPLocator::setPhysicalPort(loc, 31090);
-    att.metatrafficUnicastLocatorList.push_back(loc);
-    get_server_client_default_guidPrefix(2, att.guidPrefix);
-    standard.push_back(att);
-
-    ASSERT_TRUE(load_environment_server_info(text, output));
-    ASSERT_EQ(output, standard);
-}
-
 TEST(Discovery, RemoteBuiltinEndpointHonoring)
 {
 
diff --git a/test/blackbox/common/DDSBlackboxTestsDiscovery.cpp b/test/blackbox/common/DDSBlackboxTestsDiscovery.cpp
index ac4e9517e05..0a7b1d0fad6 100644
--- a/test/blackbox/common/DDSBlackboxTestsDiscovery.cpp
+++ b/test/blackbox/common/DDSBlackboxTestsDiscovery.cpp
@@ -112,14 +112,6 @@ TEST(DDSDiscovery, AddDiscoveryServerToListUDP)
     // Set participant as server
     WireProtocolConfigQos server_1_qos;
     server_1_qos.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::SERVER;
-    // Generate random GUID prefix
-    srand(static_cast<unsigned>(time(nullptr)));
-    GuidPrefix_t server_1_prefix;
-    for (auto i = 0; i < 12; i++)
-    {
-        server_1_prefix.value[i] = eprosima::fastdds::rtps::octet(rand() % 254);
-    }
-    server_1_qos.prefix = server_1_prefix;
     // Generate server's listening locator
     Locator_t locator_server_1;
     IPLocator::setIPv4(locator_server_1, 127, 0, 0, 1);
@@ -134,10 +126,6 @@ TEST(DDSDiscovery, AddDiscoveryServerToListUDP)
     // Set participant as server
     WireProtocolConfigQos server_2_qos;
     server_2_qos.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::SERVER;
-    // Generate random GUID prefix
-    GuidPrefix_t server_2_prefix = server_1_prefix;
-    server_2_prefix.value[11]++;
-    server_2_qos.prefix = server_2_prefix;
     // Generate server's listening locator
     Locator_t locator_server_2;
     IPLocator::setIPv4(locator_server_2, 127, 0, 0, 1);
@@ -153,10 +141,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListUDP)
     WireProtocolConfigQos client_qos;
     client_qos.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::CLIENT;
     // Connect to first server
-    RemoteServerAttributes server_1_att;
-    server_1_att.guidPrefix = server_1_prefix;
-    server_1_att.metatrafficUnicastLocatorList.push_back(Locator_t(locator_server_1));
-    client_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_1_att);
+    client_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_1);
     // Init client
     ASSERT_TRUE(client.wire_protocol(client_qos).init_participant());
 
@@ -169,10 +154,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListUDP)
     server_2.wait_discovery(std::chrono::seconds::zero(), 0, true);
 
     /* Add server_2 to client */
-    RemoteServerAttributes server_2_att;
-    server_2_att.guidPrefix = server_2_prefix;
-    server_2_att.metatrafficUnicastLocatorList.push_back(Locator_t(locator_server_2));
-    client_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_2_att);
+    client_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_2);
     // Update client's servers list
     ASSERT_TRUE(client.update_wire_protocol(client_qos));
 
@@ -182,7 +164,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListUDP)
     server_2.wait_discovery(std::chrono::seconds::zero(), 1, true);
 
     /* Add server_2 to server_1 */
-    server_1_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_2_att);
+    server_1_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_2);
     ASSERT_TRUE(server_1.update_wire_protocol(server_1_qos));
 
     /* Check that they all know each other */
@@ -212,13 +194,6 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     PubSubParticipant<HelloWorldPubSubType> server_1(0u, 0u, 0u, 0u);
     // Set participant as server
     WireProtocolConfigQos server_1_qos;
-    // Generate random GUID prefix
-    srand(static_cast<unsigned>(time(nullptr)));
-    GuidPrefix_t server_1_prefix;
-    for (auto i = 0; i < 12; i++)
-    {
-        server_1_prefix.value[i] = eprosima::fastdds::rtps::octet(rand() % 254);
-    }
     uint16_t server_1_port = W_UNICAST_PORT_RANDOM_NUMBER_STR;
     Locator_t locator_server_1;
     // Add TCP transport
@@ -226,8 +201,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     descriptor_1->add_listener_port(server_1_port);
 
     // Init server
-    ASSERT_TRUE(server_1.fill_server_qos(server_1_qos, server_1_prefix, locator_server_1, server_1_port,
-            LOCATOR_KIND_TCPv4)
+    ASSERT_TRUE(server_1.fill_server_qos(server_1_qos, locator_server_1, server_1_port, LOCATOR_KIND_TCPv4)
                     .disable_builtin_transport()
                     .add_user_transport_to_pparams(descriptor_1)
                     .init_participant());
@@ -236,8 +210,6 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     PubSubParticipant<HelloWorldPubSubType> server_2(0u, 0u, 0u, 0u);
     // Set participant as server
     WireProtocolConfigQos server_2_qos;
-    GuidPrefix_t server_2_prefix = server_1_prefix;
-    server_2_prefix.value[11]++;
     Locator_t locator_server_2;
     uint16_t server_2_port = server_1_port + 1;
     // Add TCP transport
@@ -245,8 +217,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     descriptor_2->add_listener_port(server_2_port);
 
     // Init server
-    ASSERT_TRUE(server_2.fill_server_qos(server_2_qos, server_2_prefix, locator_server_2, server_2_port,
-            LOCATOR_KIND_TCPv4)
+    ASSERT_TRUE(server_2.fill_server_qos(server_2_qos, locator_server_2, server_2_port, LOCATOR_KIND_TCPv4)
                     .disable_builtin_transport()
                     .add_user_transport_to_pparams(descriptor_2)
                     .init_participant());
@@ -258,10 +229,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     WireProtocolConfigQos client_qos_1;
     client_qos_1.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::CLIENT;
     // Connect to first server
-    RemoteServerAttributes server_1_att;
-    server_1_att.guidPrefix = server_1_prefix;
-    server_1_att.metatrafficUnicastLocatorList.push_back(Locator_t(locator_server_1));
-    client_qos_1.builtin.discovery_config.m_DiscoveryServers.push_back(server_1_att);
+    client_qos_1.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_1);
     auto descriptor_3 = std::make_shared<eprosima::fastdds::rtps::TCPv4TransportDescriptor>();
     uint16_t client_1_port = server_1_port + 10;
     descriptor_3->add_listener_port(client_1_port);
@@ -277,7 +245,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     WireProtocolConfigQos client_qos_2;
     client_qos_2.builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::CLIENT;
     // Connect to first server
-    client_qos_2.builtin.discovery_config.m_DiscoveryServers.push_back(server_1_att);
+    client_qos_2.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_1);
     auto descriptor_4 = std::make_shared<eprosima::fastdds::rtps::TCPv4TransportDescriptor>();
     uint16_t client_2_port = server_1_port - 10;
     descriptor_4->add_listener_port(client_2_port);
@@ -293,10 +261,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     server_2.wait_discovery(std::chrono::seconds::zero(), 0, true); // Knows no one
 
     /* Add server_2 to client */
-    RemoteServerAttributes server_2_att;
-    server_2_att.guidPrefix = server_2_prefix;
-    server_2_att.metatrafficUnicastLocatorList.push_back(Locator_t(locator_server_2));
-    client_qos_1.builtin.discovery_config.m_DiscoveryServers.push_back(server_2_att);
+    client_qos_1.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_2);
     // Update client_1's servers list
     ASSERT_TRUE(client_1.update_wire_protocol(client_qos_1));
 
@@ -306,7 +271,7 @@ TEST(DDSDiscovery, AddDiscoveryServerToListTCP)
     server_2.wait_discovery(std::chrono::seconds::zero(), 1, true); // Knows client1
 
     /* Add server_2 to server_1 */
-    server_1_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_2_att);
+    server_1_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_2);
     ASSERT_TRUE(server_1.update_wire_protocol(server_1_qos));
 
     server_1.wait_discovery(std::chrono::seconds::zero(), 3, true); // Knows client1, client2 and server2
@@ -328,21 +293,13 @@ TEST(DDSDiscovery, ServersConnectionTCP)
     PubSubParticipant<HelloWorldPubSubType> server_1(0u, 0u, 0u, 0u);
     // Set participant as server
     WireProtocolConfigQos server_1_qos;
-    // Generate random GUID prefix
-    srand(static_cast<unsigned>(time(nullptr)));
-    GuidPrefix_t server_1_prefix;
-    for (auto i = 0; i < 12; i++)
-    {
-        server_1_prefix.value[i] = eprosima::fastdds::rtps::octet(rand() % 254);
-    }
     Locator_t locator_server_1;
     uint16_t server_1_port = W_UNICAST_PORT_RANDOM_NUMBER_STR;
     // Add TCP transport
     auto descriptor_1 = std::make_shared<eprosima::fastdds::rtps::TCPv4TransportDescriptor>();
     descriptor_1->add_listener_port(server_1_port);
     // Init server
-    ASSERT_TRUE(server_1.fill_server_qos(server_1_qos, server_1_prefix, locator_server_1, server_1_port,
-            LOCATOR_KIND_TCPv4)
+    ASSERT_TRUE(server_1.fill_server_qos(server_1_qos, locator_server_1, server_1_port, LOCATOR_KIND_TCPv4)
                     .disable_builtin_transport()
                     .add_user_transport_to_pparams(descriptor_1)
                     .init_participant());
@@ -351,8 +308,6 @@ TEST(DDSDiscovery, ServersConnectionTCP)
     PubSubParticipant<HelloWorldPubSubType> server_2(0u, 0u, 0u, 0u);
     // Set participant as server
     WireProtocolConfigQos server_2_qos;
-    GuidPrefix_t server_2_prefix = server_1_prefix;
-    server_2_prefix.value[11]++;
     Locator_t locator_server_2;
     uint16_t server_2_port = server_1_port + 1;
     // Add TCP transport
@@ -360,14 +315,10 @@ TEST(DDSDiscovery, ServersConnectionTCP)
     descriptor_2->add_listener_port(server_2_port);
 
     // Connect to first server
-    RemoteServerAttributes server_1_att;
-    server_1_att.guidPrefix = server_1_prefix;
-    server_1_att.metatrafficUnicastLocatorList.push_back(Locator_t(locator_server_1));
-    server_2_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_1_att);
+    server_2_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_1);
 
     // Init server
-    ASSERT_TRUE(server_2.fill_server_qos(server_2_qos, server_2_prefix, locator_server_2, server_2_port,
-            LOCATOR_KIND_TCPv4)
+    ASSERT_TRUE(server_2.fill_server_qos(server_2_qos, locator_server_2, server_2_port, LOCATOR_KIND_TCPv4)
                     .disable_builtin_transport()
                     .add_user_transport_to_pparams(descriptor_2)
                     .init_participant());
@@ -376,19 +327,16 @@ TEST(DDSDiscovery, ServersConnectionTCP)
     PubSubParticipant<HelloWorldPubSubType> server_3(0u, 0u, 0u, 0u);
     // Set participant as server
     WireProtocolConfigQos server_3_qos;
-    GuidPrefix_t server_3_prefix = server_1_prefix;
-    server_3_prefix.value[11]--;
     Locator_t locator_server_3;
     uint16_t server_3_port = server_1_port - 1;
     // Add TCP transport
     auto descriptor_3 = std::make_shared<eprosima::fastdds::rtps::TCPv4TransportDescriptor>();
     descriptor_3->add_listener_port(server_3_port);
     // Connect to first server
-    server_3_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_1_att);
+    server_3_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_1);
 
     // Init server
-    ASSERT_TRUE(server_3.fill_server_qos(server_3_qos, server_3_prefix, locator_server_3, server_3_port,
-            LOCATOR_KIND_TCPv4)
+    ASSERT_TRUE(server_3.fill_server_qos(server_3_qos, locator_server_3, server_3_port, LOCATOR_KIND_TCPv4)
                     .disable_builtin_transport()
                     .add_user_transport_to_pparams(descriptor_3)
                     .init_participant());
@@ -399,10 +347,7 @@ TEST(DDSDiscovery, ServersConnectionTCP)
     server_3.wait_discovery(std::chrono::seconds::zero(), 1, true); // Knows server1
 
     /* Add server_3 to server_2 */
-    RemoteServerAttributes server_3_att;
-    server_3_att.guidPrefix = server_3_prefix;
-    server_3_att.metatrafficUnicastLocatorList.push_back(Locator_t(locator_server_3));
-    server_2_qos.builtin.discovery_config.m_DiscoveryServers.push_back(server_3_att);
+    server_2_qos.builtin.discovery_config.m_DiscoveryServers.push_back(locator_server_3);
     ASSERT_TRUE(server_2.update_wire_protocol(server_2_qos));
 
     // Check adding servers after initialization
@@ -680,7 +625,6 @@ TEST(DDSDiscovery, ParticipantProxyPhysicalData)
         std::atomic<bool>* found_;
     };
 
-    std::srand(static_cast<unsigned int>(std::time(nullptr)));
     int domain_id = std::rand() % 100;
 
     std::vector<std::string> physical_property_names =
diff --git a/test/blackbox/discovery_participants_client_server_profile.xml b/test/blackbox/discovery_participants_client_server_profile.xml
index 8b938867898..3dd5914fcb6 100644
--- a/test/blackbox/discovery_participants_client_server_profile.xml
+++ b/test/blackbox/discovery_participants_client_server_profile.xml
@@ -28,16 +28,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>14521</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>14521</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
@@ -51,16 +47,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>14521</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>14521</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_ds_1_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_ds_1_sub_profile.xml
index e67e32c0fcc..331f0031b52 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_ds_1_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_ds_1_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.01.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11812</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11812</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_pub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_pub_profile.xml
index b5f7ec9d1d4..31657f0ae7e 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_pub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_pub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_sub_profile.xml
index 6c5d3a197d5..dbdb2eb9f7f 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_msg_crypto_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_ds_1_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_ds_1_sub_profile.xml
index e037e744c51..410d4d90f4c 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_ds_1_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_ds_1_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.01.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11812</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11812</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_pub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_pub_profile.xml
index d5b84f3c0d5..db3edf754a7 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_pub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_pub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_sub_profile.xml
index 086b0a06969..ec5c6a8c8d9 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_no_rtps_protection_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_ds_1_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_ds_1_sub_profile.xml
index 10223bc36fb..956c8f8ba75 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_ds_1_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_ds_1_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.01.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11812</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11812</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_pub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_pub_profile.xml
index 4af859998c4..cd19b6ba3f4 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_pub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_pub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_sub_profile.xml
index a40f5f4d40e..0c11d388f62 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_discovery_protection_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_ds_1_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_ds_1_sub_profile.xml
index 1d4d62f4ca2..977c0d995c3 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_ds_1_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_ds_1_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.01.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11812</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11812</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_pub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_pub_profile.xml
index 21a901955ef..9ef40f91aca 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_pub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_pub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_sub_profile.xml b/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_sub_profile.xml
index b2eb6faca6a..682bed01414 100644
--- a/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_sub_profile.xml
+++ b/test/dds/communication/security/secure_ds_simple_secure_no_rtps_protection_sub_profile.xml
@@ -7,16 +7,12 @@
                     <discovery_config>
                         <discoveryProtocol>CLIENT</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                 </builtin>
diff --git a/test/dds/communication/security/secure_simple_ds_server_idx_1_profile.xml b/test/dds/communication/security/secure_simple_ds_server_idx_1_profile.xml
index 404383ebbe5..2c2856e92c0 100644
--- a/test/dds/communication/security/secure_simple_ds_server_idx_1_profile.xml
+++ b/test/dds/communication/security/secure_simple_ds_server_idx_1_profile.xml
@@ -8,16 +8,12 @@
                     <discovery_config>
                         <discoveryProtocol>SERVER</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                     <metatrafficUnicastLocatorList>
diff --git a/test/dds/communication/security/secure_simple_ds_server_no_discovery_no_rtps_protection_idx_1_profile.xml b/test/dds/communication/security/secure_simple_ds_server_no_discovery_no_rtps_protection_idx_1_profile.xml
index 243f66392cb..486240ebcb6 100644
--- a/test/dds/communication/security/secure_simple_ds_server_no_discovery_no_rtps_protection_idx_1_profile.xml
+++ b/test/dds/communication/security/secure_simple_ds_server_no_discovery_no_rtps_protection_idx_1_profile.xml
@@ -8,16 +8,12 @@
                     <discovery_config>
                         <discoveryProtocol>SERVER</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                     <metatrafficUnicastLocatorList>
diff --git a/test/dds/communication/security/secure_simple_ds_server_no_discovery_protection_idx_1_profile.xml b/test/dds/communication/security/secure_simple_ds_server_no_discovery_protection_idx_1_profile.xml
index 2426ff96639..2791b276849 100644
--- a/test/dds/communication/security/secure_simple_ds_server_no_discovery_protection_idx_1_profile.xml
+++ b/test/dds/communication/security/secure_simple_ds_server_no_discovery_protection_idx_1_profile.xml
@@ -8,16 +8,12 @@
                     <discovery_config>
                         <discoveryProtocol>SERVER</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                     <metatrafficUnicastLocatorList>
diff --git a/test/dds/communication/security/secure_simple_ds_server_no_rtps_protection_idx_1_profile.xml b/test/dds/communication/security/secure_simple_ds_server_no_rtps_protection_idx_1_profile.xml
index e8eaf50aeed..60210161fb7 100644
--- a/test/dds/communication/security/secure_simple_ds_server_no_rtps_protection_idx_1_profile.xml
+++ b/test/dds/communication/security/secure_simple_ds_server_no_rtps_protection_idx_1_profile.xml
@@ -8,16 +8,12 @@
                     <discovery_config>
                         <discoveryProtocol>SERVER</discoveryProtocol>
                         <discoveryServersList>
-                            <RemoteServer prefix="44.53.00.5f.45.50.52.4f.53.49.4d.41">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>127.0.0.1</address>
-                                            <port>11811</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>127.0.0.1</address>
+                                    <port>11811</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
                     </discovery_config>
                     <metatrafficUnicastLocatorList>
diff --git a/test/dds/discovery/client_server_dynamic_discovery.py b/test/dds/discovery/client_server_dynamic_discovery.py
index db8895d78c0..9d7a6635622 100644
--- a/test/dds/discovery/client_server_dynamic_discovery.py
+++ b/test/dds/discovery/client_server_dynamic_discovery.py
@@ -162,7 +162,6 @@ def third_step(outq):
 
 def fourth_step(outq):
     fourth_step_fulfilled = False
-    warning_client_1 = False
     warning_client_2 = False
     count = 0
     initial_time = time.time()
@@ -178,13 +177,11 @@ def fourth_step(outq):
             if 'Trying to add Discovery Servers to a participant which is not a SERVER, BACKUP or an' in line \
                 and 'overriden CLIENT (SIMPLE participant transformed into CLIENT with the environment variable)' in line:
                 warning_client_2 = True
-            elif 'Discovery Servers cannot be removed from the list; they can only be added' in line:
-                warning_client_1 = True
             elif 'discovered participant' in line:
                 count = count + 1
         except queue.Empty:
             # Ensure that 2 s has passed so the file watch can detect that the file has changed
-            if warning_client_1 and warning_client_2 and count == 0 and (time.time() - initial_time) > 2:
+            if warning_client_2 and count == 0 and (time.time() - initial_time) > 2:
                 fourth_step_fulfilled = True
             elif count > 0:
                 print('ERROR: More discoveries than expected')
@@ -199,7 +196,6 @@ def fourth_step(outq):
 
 def fifth_step(outq):
     fifth_step_fulfilled = False
-    warning = False
     count = 0
     initial_time = time.time()
     while not fifth_step_fulfilled:
@@ -211,13 +207,11 @@ def fifth_step(outq):
             print(line)
             sys.stdout.flush()
 
-            if 'Discovery Servers cannot be removed from the list; they can only be added' in line:
-                warning = True
-            elif 'discovered participant' in line:
+            if 'discovered participant' in line:
                 count = count + 1
         except queue.Empty:
             # Ensure that 2 s has passed so the file watch can detect that the file has changed
-            if warning and count == 0 and (time.time() - initial_time) > 2:
+            if count == 0 and (time.time() - initial_time) > 2:
                 fifth_step_fulfilled = True
             elif count > 0:
                 print('ERROR: More discoveries than expected')
@@ -282,11 +276,11 @@ def communication(proc, outq, outt, cv):
                     cv.acquire()
                     cv.notify()
                     cv.release()
-                
- 
+
+
             except queue.Empty:
                 sys.stdout.flush()
-            
+
             time.sleep(0.1)
     finally:
         proc.terminate()
diff --git a/test/mock/rtps/BuiltinProtocols/rtps/builtin/BuiltinProtocols.h b/test/mock/rtps/BuiltinProtocols/rtps/builtin/BuiltinProtocols.h
index 91f737d76b6..f0d7cdd42be 100644
--- a/test/mock/rtps/BuiltinProtocols/rtps/builtin/BuiltinProtocols.h
+++ b/test/mock/rtps/BuiltinProtocols/rtps/builtin/BuiltinProtocols.h
@@ -50,7 +50,7 @@ class BuiltinProtocols
     BuiltinAttributes m_att;
 
     //! Known discovery and backup server container
-    std::list<eprosima::fastdds::rtps::RemoteServerAttributes> m_DiscoveryServers;
+    LocatorList_t m_DiscoveryServers;
 
     //!Pointer to the RTPSParticipantImpl.
     RTPSParticipantImpl* mp_participantImpl {nullptr};
diff --git a/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp b/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp
index da946d6ce03..036de3307af 100644
--- a/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp
+++ b/test/mock/rtps/RTPSParticipantAttributes/fastdds/rtps/attributes/RTPSParticipantAttributes.hpp
@@ -29,7 +29,6 @@
 #include <fastdds/rtps/attributes/PropertyPolicy.hpp>
 #include <fastdds/rtps/attributes/ResourceManagement.hpp>
 #include <fastdds/rtps/attributes/RTPSParticipantAllocationAttributes.hpp>
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
 #include <fastdds/rtps/attributes/ThreadSettings.hpp>
 #include <fastdds/rtps/common/Locator.hpp>
 #include <fastdds/rtps/common/PortParameters.hpp>
@@ -128,6 +127,11 @@ inline std::ostream& operator <<(
     return output;
 }
 
+// Port used if the ros environment variable doesn't specify one
+constexpr uint16_t DEFAULT_ROS2_SERVER_PORT = 11811;
+// Port used by default for tcp transport
+constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 42100;
+
 //! Filtering flags when discovering participants
 enum ParticipantFilteringFlags : uint32_t
 {
@@ -275,8 +279,8 @@ class DiscoverySettings
      */
     Duration_t discoveryServer_client_syncperiod = { 0, 450 * 1000000}; // 450 milliseconds
 
-    //! Discovery Server settings, only needed if use_CLIENT_DiscoveryProtocol=true
-    eprosima::fastdds::rtps::RemoteServerList_t m_DiscoveryServers;
+    //! Discovery Server initial connections, needed if `discoveryProtocol` = CLIENT | SUPER_CLIENT | SERVER | BACKUP
+    eprosima::fastdds::rtps::LocatorList m_DiscoveryServers;
 
     //! Filtering participants out depending on location
     ParticipantFilteringFlags ignoreParticipantFlags = ParticipantFilteringFlags::NO_FILTER;
diff --git a/test/system/tools/fastdds/tests.py b/test/system/tools/fastdds/tests.py
index 25f3ad194d6..ea9b4c312f3 100644
--- a/test/system/tools/fastdds/tests.py
+++ b/test/system/tools/fastdds/tests.py
@@ -109,7 +109,7 @@ def test_fastdds_shm(install_path):
 
 def test_fastdds_discovery(install_path, setup_script_path):
     """Test that discovery command runs."""
-    args = ' discovery'
+    args = ' discovery -h'
     ret = subprocess.call(
         cmd(install_path=install_path,
             setup_script_path=setup_script_path,
@@ -123,9 +123,11 @@ def test_fastdds_discovery(install_path, setup_script_path):
 
 def test_ros_discovery(install_path, setup_script_path):
     """Test that discovery command runs."""
+    args = ' -h'
     ret = subprocess.call(
         cmd(install_path=install_path,
-            setup_script_path=setup_script_path),
+            setup_script_path=setup_script_path,
+            args=args),
         shell=True)
 
     if 0 != ret:
diff --git a/test/system/tools/fds/test_wrong_xml_discovery_server_profile.xml b/test/system/tools/fds/test_wrong_xml_discovery_server_profile.xml
index dcd1cff8ad2..669f00efbc8 100644
--- a/test/system/tools/fds/test_wrong_xml_discovery_server_profile.xml
+++ b/test/system/tools/fds/test_wrong_xml_discovery_server_profile.xml
@@ -37,22 +37,4 @@
             </builtin>
         </rtps>
     </participant>
-
-    <participant profile_name="UDP_no_prefix">
-        <rtps>
-            <builtin>
-                <discovery_config>
-                    <discoveryProtocol>SERVER</discoveryProtocol>
-                </discovery_config>
-                <metatrafficUnicastLocatorList>
-                    <locator>
-                        <udpv4>
-                            <address>127.0.0.5</address>
-                            <port>11817</port>
-                        </udpv4>
-                    </locator>
-                </metatrafficUnicastLocatorList>
-            </builtin>
-        </rtps>
-    </participant>
 </profiles>
diff --git a/test/system/tools/fds/test_xml_discovery_server_profile.xml b/test/system/tools/fds/test_xml_discovery_server_profile.xml
index 977097b071e..e96c83eb925 100644
--- a/test/system/tools/fds/test_xml_discovery_server_profile.xml
+++ b/test/system/tools/fds/test_xml_discovery_server_profile.xml
@@ -88,4 +88,22 @@
             </builtin>
         </rtps>
     </participant>
+
+    <participant profile_name="UDP_no_prefix">
+        <rtps>
+            <builtin>
+                <discovery_config>
+                    <discoveryProtocol>SERVER</discoveryProtocol>
+                </discovery_config>
+                <metatrafficUnicastLocatorList>
+                    <locator>
+                        <udpv4>
+                            <address>127.0.0.5</address>
+                            <port>11817</port>
+                        </udpv4>
+                    </locator>
+                </metatrafficUnicastLocatorList>
+            </builtin>
+        </rtps>
+    </participant>
 </profiles>
diff --git a/test/system/tools/fds/test_xml_secure_discovery_server_profile.xml b/test/system/tools/fds/test_xml_secure_discovery_server_profile.xml
index 371103074fc..a4198fc7e17 100644
--- a/test/system/tools/fds/test_xml_secure_discovery_server_profile.xml
+++ b/test/system/tools/fds/test_xml_secure_discovery_server_profile.xml
@@ -12,7 +12,7 @@
                         <locator>
                             <udpv4>
                                 <address>127.0.0.1</address>
-                                <port>11811</port>
+                                <port>32823</port>
                             </udpv4>
                         </locator>
                     </metatrafficUnicastLocatorList>
@@ -74,7 +74,7 @@
                         <locator>
                             <udpv4>
                                 <address>127.0.0.1</address>
-                                <port>11811</port>
+                                <port>32823</port>
                             </udpv4>
                         </locator>
                     </metatrafficUnicastLocatorList>
diff --git a/test/system/tools/fds/tests.py b/test/system/tools/fds/tests.py
index 166cfcce602..097e810a682 100644
--- a/test/system/tools/fds/tests.py
+++ b/test/system/tools/fds/tests.py
@@ -499,6 +499,17 @@ def test_fast_discovery_backup(fast_discovery_tool):
     sys.exit(exit_code)
 
 
+def test_fast_discovery_no_prefix(fast_discovery_tool):
+    """Test to set a random GUID when no server ID is provided"""
+
+    XML_file_path = "test_xml_discovery_server_profile.xml"
+    command = [fast_discovery_tool, '-x', 'UDP_no_prefix@' + XML_file_path]
+    output, err, exit_code = send_command(command)
+    EXPECTED_OUTPUT = "UDPv4:[127.0.0.5]:11817"
+    exit_code = check_output(output, err, EXPECTED_OUTPUT, False)
+    sys.exit(exit_code)
+
+
 def test_fast_discovery_no_XML(fast_discovery_tool):
     """Test that checks output when the XML file provided does not exist"""
 
@@ -528,16 +539,6 @@ def test_fast_discovery_incorrect_participant(fast_discovery_tool):
     sys.exit(exit_code)
 
 
-def test_fast_discovery_no_prefix(fast_discovery_tool):
-    """Test failure when no server ID is provided"""
-
-    XML_file_path = "test_wrong_xml_discovery_server_profile.xml"
-    command = [fast_discovery_tool, '-x', 'UDP_no_prefix@' + XML_file_path]
-    output, err, exit_code = send_command(command)
-    exit_code = check_output(output, err, "Server id is mandatory if not defined in the XML file", True)
-    sys.exit(exit_code)
-
-
 def test_fast_discovery_several_server_ids(fast_discovery_tool):
     """Test failure when several Server IDs are provided"""
 
@@ -588,7 +589,7 @@ def test_fast_discovery_security_enabled_xml_prefix(fast_discovery_tool):
         sys.exit(exit_code)
     EXPECTED_OUTPUTS = [
         "Security:           YES",
-        "44.53.00.5f.45.50.52.4f.53.49.4d.41",
+        "UDPv4:[127.0.0.1]:32823",
     ]
     for pattern in EXPECTED_OUTPUTS:
         exit_code = check_output(output, err, pattern, False)
@@ -608,7 +609,7 @@ def test_fast_discovery_security_enabled_cli_prefix(fast_discovery_tool):
         sys.exit(exit_code)
     EXPECTED_OUTPUTS = [
         "Security:           YES",
-        "44.53.00.5f.45.50.52.4f.53.49.4d.41",
+        "UDPv4:[127.0.0.1]:32823",
     ]
     for pattern in EXPECTED_OUTPUTS:
         exit_code = check_output(output, err, pattern, False)
diff --git a/test/system/tools/xmlvalidation/all_profile.xml b/test/system/tools/xmlvalidation/all_profile.xml
index 577e3b09bd5..a03c7986268 100644
--- a/test/system/tools/xmlvalidation/all_profile.xml
+++ b/test/system/tools/xmlvalidation/all_profile.xml
@@ -110,16 +110,12 @@
                         <discoveryProtocol>CLIENT</discoveryProtocol>
 
                         <discoveryServersList>
-                            <RemoteServer prefix="72.61.73.70.66.61.72.6d.74.65.73.74">
-                                <metatrafficUnicastLocatorList>
-                                    <locator>
-                                        <udpv4>
-                                            <address>192.168.10.57</address>
-                                            <port>56542</port>
-                                        </udpv4>
-                                    </locator>
-                                </metatrafficUnicastLocatorList>
-                            </RemoteServer>
+                            <locator>
+                                <udpv4>
+                                    <address>192.168.10.57</address>
+                                    <port>56542</port>
+                                </udpv4>
+                            </locator>
                         </discoveryServersList>
 
                         <ignoreParticipantFlags>FILTER_DIFFERENT_HOST</ignoreParticipantFlags>
diff --git a/test/system/tools/xmlvalidation/domainParticipant_profile.xml b/test/system/tools/xmlvalidation/domainParticipant_profile.xml
index b7bbe2fa7bb..3310898a762 100644
--- a/test/system/tools/xmlvalidation/domainParticipant_profile.xml
+++ b/test/system/tools/xmlvalidation/domainParticipant_profile.xml
@@ -109,16 +109,12 @@
                     <discoveryProtocol>CLIENT</discoveryProtocol>
 
                     <discoveryServersList>
-                        <RemoteServer prefix="72.61.73.70.66.61.72.6d.74.65.73.74">
-                            <metatrafficUnicastLocatorList>
-                                <locator>
-                                    <udpv4>
-                                        <address>192.168.10.57</address>
-                                        <port>56542</port>
-                                    </udpv4>
-                                </locator>
-                            </metatrafficUnicastLocatorList>
-                        </RemoteServer>
+                        <locator>
+                            <udpv4>
+                                <address>192.168.10.57</address>
+                                <port>56542</port>
+                            </udpv4>
+                        </locator>
                     </discoveryServersList>
 
                     <ignoreParticipantFlags>FILTER_DIFFERENT_HOST</ignoreParticipantFlags>
diff --git a/test/unittest/dds/participant/ParticipantTests.cpp b/test/unittest/dds/participant/ParticipantTests.cpp
index 0f3cd586f17..6e3461fdb4b 100644
--- a/test/unittest/dds/participant/ParticipantTests.cpp
+++ b/test/unittest/dds/participant/ParticipantTests.cpp
@@ -52,7 +52,6 @@
 #include <fastdds/dds/xtypes/dynamic_types/TypeDescriptor.hpp>
 #include <fastdds/LibrarySettings.hpp>
 #include <fastdds/rtps/attributes/RTPSParticipantAttributes.hpp>
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
 #include <fastdds/rtps/common/Locator.hpp>
 #include <fastdds/rtps/participant/RTPSParticipant.hpp>
 #include <fastdds/rtps/transport/shared_mem/SharedMemTransportDescriptor.hpp>
@@ -63,6 +62,7 @@
 #include <fastdds/utils/IPLocator.hpp>
 
 #include <fastdds/domain/DomainParticipantImpl.hpp>
+#include <rtps/attributes/ServerAttributes.hpp>
 #include <utils/SystemInfo.hpp>
 #include <xmlparser/attributes/PublisherAttributes.hpp>
 #include <xmlparser/attributes/SubscriberAttributes.hpp>
@@ -881,54 +881,39 @@ void helper_wait_for_at_least_entries(
 }
 
 void expected_remote_server_list_output(
-        rtps::RemoteServerList_t& output)
+        rtps::LocatorList& output)
 {
-    rtps::RemoteServerAttributes server;
     fastdds::rtps::Locator_t locator;
     fastdds::rtps::IPLocator::setIPv4(locator, "84.22.253.128");
     locator.port = 8888;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(0, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
 
-    server.clear();
     fastdds::rtps::IPLocator::setIPv4(locator, "127.0.0.1");
     locator.port = 1234;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(2, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
 
     std::istringstream("UDPv6:[2a02:ec80:600:ed1a::3]:8783") >> locator;
-    server.clear();
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(3, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
 }
 
 void set_participant_qos(
         DomainParticipantQos& qos,
-        rtps::RemoteServerList_t& output)
+        rtps::LocatorList& output)
 {
-    rtps::RemoteServerAttributes server;
     fastdds::rtps::Locator_t locator;
-    server.ReadguidPrefix("44.53.00.5f.45.50.52.4f.53.49.4d.00");
     fastdds::rtps::IPLocator::setIPv4(locator, "192.168.1.133");
     locator.port = 64863;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server);
-    output.push_back(server);
+    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator);
+    output.push_back(locator);
 }
 
 void set_server_qos(
         DomainParticipantQos& qos)
 {
-    rtps::RemoteServerAttributes server;
     fastdds::rtps::Locator_t locator;
-    server.ReadguidPrefix(rtps::DEFAULT_ROS2_SERVER_GUIDPREFIX);
     fastdds::rtps::IPLocator::setIPv4(locator, "172.17.0.5");
     locator.port = 4321;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server);
+    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator);
     qos.wire_protocol().builtin.discovery_config.discoveryProtocol = fastdds::rtps::DiscoveryProtocol::SERVER;
     fastdds::rtps::IPLocator::setIPv4(locator, "127.0.0.1");
     locator.port = 5432;
@@ -974,10 +959,8 @@ void set_and_check_with_environment_file(
 {
     const static std::regex ROS2_IPV4_PATTERN(R"(^((?:[0-9]{1,3}\.){3}[0-9]{1,3})?:?(?:(\d+))?$)");
 
-    rtps::RemoteServerList_t output;
-    rtps::RemoteServerAttributes server;
+    rtps::LocatorList output;
     fastdds::rtps::Locator_t locator;
-    int id = 0;
 
     std::ofstream file(filename);
     file << "{\"ROS_DISCOVERY_SERVER\": ";
@@ -1001,14 +984,7 @@ void set_and_check_with_environment_file(
         int port = stoi((++it)->str());
         fastdds::rtps::IPLocator::setPhysicalPort(locator, static_cast<uint16_t>(port));
 
-        // add the server to the list
-        server.clear();
-        server.metatrafficUnicastLocatorList.push_back(locator);
-        if (!get_server_client_default_guidPrefix(id++, server.guidPrefix))
-        {
-            throw std::invalid_argument("The maximum number of default discovery servers has been reached");
-        }
-        output.push_back(server);
+        output.push_back(locator);
         file << l;
     }
     file << "\"}";
@@ -1031,8 +1007,8 @@ TEST(ParticipantTests, SimpleParticipantRemoteServerListConfiguration)
 {
     set_environment_variable();
 
-    rtps::RemoteServerList_t output;
-    rtps::RemoteServerList_t qos_output;
+    rtps::LocatorList output;
+    rtps::LocatorList qos_output;
     expected_remote_server_list_output(output);
 
     DomainParticipantQos qos;
@@ -1084,8 +1060,8 @@ TEST(ParticipantTests, TransformSimpleParticipantToSuperclientByEnvVariable)
     ASSERT_EQ(0, setenv(rtps::ROS_SUPER_CLIENT, "false", 1));
 #endif // _WIN32
 
-    rtps::RemoteServerList_t output;
-    rtps::RemoteServerList_t qos_output;
+    rtps::LocatorList output;
+    rtps::LocatorList qos_output;
     expected_remote_server_list_output(output);
 
     DomainParticipantQos qos;
@@ -1171,16 +1147,13 @@ TEST(ParticipantTests, SimpleParticipantRemoteServerListConfigurationDNS)
     set_environment_variable("www.acme.com.test");
 
     // fill in expected result
-    rtps::RemoteServerAttributes server;
     fastdds::rtps::Locator_t locator4(11811), locator6(LOCATOR_KIND_UDPv6, 11811);
     fastdds::rtps::IPLocator::setIPv4(locator4, "216.58.215.164");
     fastdds::rtps::IPLocator::setIPv6(locator6, "2a00:1450:400e:803::2004");
-    server.metatrafficUnicastLocatorList.push_back(locator4);
-    server.metatrafficUnicastLocatorList.push_back(locator6);
-    get_server_client_default_guidPrefix(0, server.guidPrefix);
 
-    rtps::RemoteServerList_t output;
-    output.push_back(server);
+    rtps::LocatorList output;
+    output.push_back(locator4);
+    output.push_back(locator6);
 
     // Create the participant
     DomainParticipant* participant = DomainParticipantFactory::get_instance()->create_participant(0,
@@ -1219,8 +1192,8 @@ TEST(ParticipantTests, SimpleParticipantDynamicAdditionRemoteServers)
     set_environment_variable();
     set_environment_file(filename);
 
-    rtps::RemoteServerList_t output;
-    rtps::RemoteServerList_t qos_output;
+    rtps::LocatorList output;
+    rtps::LocatorList qos_output;
     expected_remote_server_list_output(output);
 
     DomainParticipantQos qos;
@@ -1243,17 +1216,14 @@ TEST(ParticipantTests, SimpleParticipantDynamicAdditionRemoteServers)
         "{\"ROS_DISCOVERY_SERVER\": \"84.22.253.128:8888;192.168.1.133:64863;UDPv4:[localhost]:1234;[2a02:ec80:600:ed1a::3]:8783\"}";
     file.close();
 
-    // Wait long enought for the file watch callback
+    // Wait long enough for the file watch callback
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     get_rtps_attributes(participant, attributes);
 
-    rtps::RemoteServerAttributes server;
     fastdds::rtps::Locator_t locator;
     fastdds::rtps::IPLocator::setIPv4(locator, "192.168.1.133");
     locator.port = 64863;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(1, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
 
     EXPECT_EQ(attributes.builtin.discovery_config.m_DiscoveryServers, output);
 #endif // APPLE
@@ -1271,7 +1241,7 @@ TEST(ParticipantTests, ClientParticipantRemoteServerListConfiguration)
     set_environment_variable();
 
     DomainParticipantQos qos;
-    rtps::RemoteServerList_t qos_output;
+    rtps::LocatorList qos_output;
     set_participant_qos(qos, qos_output);
 
     qos.wire_protocol().builtin.discovery_config.discoveryProtocol = fastdds::rtps::DiscoveryProtocol::CLIENT;
@@ -1325,7 +1295,7 @@ TEST(ParticipantTests, ServerParticipantRemoteServerListConfiguration)
     set_environment_variable();
 
     DomainParticipantQos qos;
-    rtps::RemoteServerList_t qos_output;
+    rtps::LocatorList qos_output;
     fastdds::rtps::Locator_t locator;
     set_participant_qos(qos, qos_output);
     qos.wire_protocol().builtin.discovery_config.discoveryProtocol = fastdds::rtps::DiscoveryProtocol::SERVER;
@@ -1347,10 +1317,9 @@ TEST(ParticipantTests, ServerParticipantRemoteServerListConfiguration)
 }
 
 /**
- * SERVER Participant with initial server with inconsistent GUID prefix.
- * Dynamic addition of servers failure.
+ * Dynamic modification of servers. Replacing previous servers with new ones.
  */
-TEST(ParticipantTests, ServerParticipantInconsistentRemoteServerListConfiguration)
+TEST(ParticipantTests, ServerParticipantReplaceRemoteServerListConfiguration)
 {
     Log::ClearConsumers();
     MockConsumer* mockConsumer = new MockConsumer("RTPS_QOS_CHECK");
@@ -1361,13 +1330,18 @@ TEST(ParticipantTests, ServerParticipantInconsistentRemoteServerListConfiguratio
     set_environment_file(filename);
 
     std::ofstream file(filename);
-    file << "{\"ROS_DISCOVERY_SERVER\": \"84.22.253.128:8888;;localhost:1234\"}";
+    file << "{\"ROS_DISCOVERY_SERVER\": \"84.22.253.128:8888;;127.0.0.1:1234\"}";
     file.close();
 
     DomainParticipantQos qos;
-    rtps::RemoteServerList_t qos_output;
+    rtps::LocatorList qos_output;
     fastdds::rtps::Locator_t locator;
-    set_participant_qos(qos, qos_output);
+    fastdds::rtps::IPLocator::setIPv4(locator, "84.22.253.128");
+    locator.port = 8888;
+    qos_output.push_back(locator);
+    fastdds::rtps::IPLocator::setIPv4(locator, "127.0.0.1");
+    locator.port = 1234;
+    qos_output.push_back(locator);
     qos.wire_protocol().builtin.discovery_config.discoveryProtocol = fastdds::rtps::DiscoveryProtocol::SERVER;
     fastdds::rtps::IPLocator::setIPv4(locator, "127.0.0.1");
     locator.port = 5432;
@@ -1377,6 +1351,7 @@ TEST(ParticipantTests, ServerParticipantInconsistentRemoteServerListConfiguratio
     DomainParticipant* participant = DomainParticipantFactory::get_instance()->create_participant(
         (uint32_t)GET_PID() % 230, qos);
     ASSERT_NE(nullptr, participant);
+#ifndef __APPLE__
     fastdds::rtps::RTPSParticipantAttributes attributes;
     get_rtps_attributes(participant, attributes);
     EXPECT_EQ(attributes.builtin.discovery_config.discoveryProtocol, fastdds::rtps::DiscoveryProtocol::SERVER);
@@ -1385,14 +1360,16 @@ TEST(ParticipantTests, ServerParticipantInconsistentRemoteServerListConfiguratio
     // Modify environment file: fails cause the initial guid prefix did not comply with the schema
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     file.open(filename);
-    file << "{\"ROS_DISCOVERY_SERVER\": \"84.22.253.128:8888;192.168.1.133:64863;localhost:1234\"}";
+    file << "{\"ROS_DISCOVERY_SERVER\": \"192.168.1.133:64863\"}";
     file.close();
+    fastdds::rtps::IPLocator::setIPv4(locator, "192.168.1.133");
+    locator.port = 64863;
+    qos_output.clear();
+    qos_output.push_back(locator);
+
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     get_rtps_attributes(participant, attributes);
     EXPECT_EQ(attributes.builtin.discovery_config.m_DiscoveryServers, qos_output);
-    // Capture log warning
-#ifndef __APPLE__
-    helper_wait_for_at_least_entries(mockConsumer, 1);
 #endif // APPLE
     DomainParticipantQos result_qos = participant->get_qos();
     EXPECT_EQ(RETCODE_OK, participant->set_qos(result_qos));
@@ -1414,21 +1391,14 @@ TEST(ParticipantTests, ServerParticipantInconsistentLocatorsRemoteServerListConf
     DomainParticipantQos qos;
     set_server_qos(qos);
 
-    rtps::RemoteServerList_t output;
-    rtps::RemoteServerAttributes server;
+    rtps::LocatorList output;
     fastdds::rtps::Locator_t locator;
-    server.clear();
     fastdds::rtps::IPLocator::setIPv4(locator, "172.17.0.5");
     locator.port = 4321;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(0, server.guidPrefix);
-    output.push_back(server);
-    server.clear();
+    output.push_back(locator);
     fastdds::rtps::IPLocator::setIPv4(locator, "192.168.1.133");
     locator.port = 64863;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(1, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
 
     DomainParticipant* participant = DomainParticipantFactory::get_instance()->create_participant(
         (uint32_t)GET_PID() % 230, qos);
@@ -1485,79 +1455,69 @@ TEST(ParticipantTests, ServerParticipantCorrectRemoteServerListConfiguration)
 
     std::ofstream file;
     file.open(filename);
-    file << "{\"ROS_DISCOVERY_SERVER\": \";UDPv4:[localhost]:1234\"}";
+    file << "{\"ROS_DISCOVERY_SERVER\": \";UDPv4:[127.0.0.1]:1234\"}";
     file.close();
 
     DomainParticipantQos qos;
+    DomainParticipantQos result_qos;
     set_server_qos(qos);
 
-    rtps::RemoteServerList_t output;
-    rtps::RemoteServerAttributes server;
+    rtps::LocatorList output;
     fastdds::rtps::Locator_t locator;
-    fastdds::rtps::IPLocator::setIPv4(locator, "172.17.0.5");
-    locator.port = 4321;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(0, server.guidPrefix);
-    output.push_back(server);
+    fastdds::rtps::IPLocator::setIPv4(locator, "127.0.0.1");
+    locator.port = 1234;
+    // Server of the filename will overwrite the one set by QoS
+    output.push_back(locator);
 
     DomainParticipant* participant = DomainParticipantFactory::get_instance()->create_participant(
         (uint32_t)GET_PID() % 230, qos);
     ASSERT_NE(nullptr, participant);
+#ifndef __APPLE__
     fastdds::rtps::RTPSParticipantAttributes attributes;
     get_rtps_attributes(participant, attributes);
     EXPECT_EQ(attributes.builtin.discovery_config.m_DiscoveryServers, output);
     // Add new server through environment file
     // Even though the server added previously through the environment file is being pinged, it is not really being
     // checked because it is not included in the attributes.
-    DomainParticipantQos result_qos;
-#ifndef __APPLE__
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     file.open(filename);
     file << "{\"ROS_DISCOVERY_SERVER\": \"172.17.0.5:4321;;192.168.1.133:64863\"}";
     file.close();
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    server.clear();
+    output.clear();
+    fastdds::rtps::IPLocator::setIPv4(locator, "172.17.0.5");
+    locator.port = 4321;
+    output.push_back(locator);
     fastdds::rtps::IPLocator::setIPv4(locator, "192.168.1.133");
     locator.port = 64863;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(2, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
     get_rtps_attributes(participant, attributes);
     EXPECT_EQ(attributes.builtin.discovery_config.m_DiscoveryServers, output);
     // Try to be consistent: add already known server
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
     file.open(filename);
-    file << "{\"ROS_DISCOVERY_SERVER\": \"172.17.0.5:4321;UDPv4:[localhost]:1234;192.168.1.133:64863\"}";
+    file << "{\"ROS_DISCOVERY_SERVER\": \"172.17.0.5:4321;UDPv4:[127.0.0.1]:1234;192.168.1.133:64863\"}";
     file.close();
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
-    server.clear();
     fastdds::rtps::IPLocator::setIPv4(locator, "127.0.0.1");
     locator.port = 1234;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(1, server.guidPrefix);
-    output.push_back(server);
+    output.push_back(locator);
     get_rtps_attributes(participant, attributes);
     EXPECT_EQ(attributes.builtin.discovery_config.m_DiscoveryServers, output);
     result_qos = participant->get_qos();
     EXPECT_EQ(RETCODE_OK, participant->set_qos(result_qos));
     // Add new server using API
-    result_qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server);
+    result_qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator);
     // RTPS layer issues a Warning because a server has been removed. However, DDS layer returns OK
     EXPECT_EQ(RETCODE_OK, participant->set_qos(result_qos));
-    server.clear();
     fastdds::rtps::IPLocator::setIPv4(locator, "192.168.1.133");
     locator.port = 64863;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(2, server.guidPrefix);
-    result_qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server);
-    server.clear();
+    result_qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator);
     fastdds::rtps::IPLocator::setIPv4(locator, "84.22.253.128");
     locator.port = 8888;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    get_server_client_default_guidPrefix(3, server.guidPrefix);
-    result_qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server);
+    result_qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator);
     EXPECT_EQ(RETCODE_OK, participant->set_qos(result_qos));
-    output.push_back(server);
+    output.push_back(locator);
     get_rtps_attributes(participant, attributes);
     EXPECT_EQ(attributes.builtin.discovery_config.m_DiscoveryServers, output);
 #endif // APPLE
@@ -1584,39 +1544,34 @@ TEST(ParticipantTests, ChangeWireProtocolQos)
     check_equivalent_qos(qos, PARTICIPANT_QOS_DEFAULT);
 
     // Check that just adding two servers is OK
-    rtps::RemoteServerAttributes server;
-    server.ReadguidPrefix("44.53.00.5f.45.50.52.4f.53.49.4d.41");
     fastdds::rtps::Locator_t locator;
     fastdds::rtps::IPLocator::setIPv4(locator, 192, 168, 1, 133);
     locator.port = 64863;
-    server.metatrafficUnicastLocatorList.push_back(locator);
-    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server);
+    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator);
 
-    rtps::RemoteServerAttributes server_2;
-    server_2.ReadguidPrefix("44.53.00.5f.45.50.52.4f.53.49.4d.42");
     fastdds::rtps::Locator_t locator_2;
     fastdds::rtps::IPLocator::setIPv4(locator_2, 192, 168, 1, 134);
     locator_2.port = 64862;
-    server_2.metatrafficUnicastLocatorList.push_back(locator_2);
-    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(server_2);
+    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.push_back(locator_2);
 
     ASSERT_TRUE(participant->set_qos(qos) == RETCODE_OK);
     DomainParticipantQos set_qos;
     participant->get_qos(set_qos);
     ASSERT_EQ(set_qos, qos);
 
-    // Check that removing one server is NOT OK
-    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.pop_front();
-    ASSERT_FALSE(participant->set_qos(qos) == RETCODE_OK);
+    // Check that removing one server is OK
+    auto front_server = qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.begin();
+    qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers.erase(*front_server);
+    ASSERT_TRUE(participant->set_qos(qos) == RETCODE_OK);
     participant->get_qos(set_qos);
-    ASSERT_FALSE(set_qos == qos);
+    ASSERT_TRUE(set_qos == qos);
 
-    // Check that removing all servers is NOT OK
-    fastdds::rtps::RemoteServerList_t servers;
+    // Check that removing all servers is OK
+    fastdds::rtps::LocatorList servers;
     qos.wire_protocol().builtin.discovery_config.m_DiscoveryServers = servers;
-    ASSERT_FALSE(participant->set_qos(qos) == RETCODE_OK);
+    ASSERT_TRUE(participant->set_qos(qos) == RETCODE_OK);
     participant->get_qos(set_qos);
-    ASSERT_FALSE(set_qos == qos);
+    ASSERT_TRUE(set_qos == qos);
 
     // Check changing wire_protocol().prefix is NOT OK
     participant->get_qos(qos);
diff --git a/test/unittest/dds/publisher/CMakeLists.txt b/test/unittest/dds/publisher/CMakeLists.txt
index 348eab958bf..7e6eb5bf810 100644
--- a/test/unittest/dds/publisher/CMakeLists.txt
+++ b/test/unittest/dds/publisher/CMakeLists.txt
@@ -78,6 +78,7 @@ set(DATAWRITERTESTS_SOURCE DataWriterTests.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/EndpointSecurityAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/PropertyPolicy.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ServerAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ThreadSettings.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/BuiltinProtocols.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/ParticipantProxyData.cpp
@@ -103,7 +104,6 @@ set(DATAWRITERTESTS_SOURCE DataWriterTests.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
-    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/liveliness/WLP.cpp
diff --git a/test/unittest/dds/subscriber/CMakeLists.txt b/test/unittest/dds/subscriber/CMakeLists.txt
index 353de14ffc6..e2264079ca5 100644
--- a/test/unittest/dds/subscriber/CMakeLists.txt
+++ b/test/unittest/dds/subscriber/CMakeLists.txt
@@ -90,7 +90,6 @@ target_include_directories(DataReaderTests PRIVATE
     ${Asio_INCLUDE_DIR}
     ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR}/include
     ${PROJECT_SOURCE_DIR}/src/cpp
-    ${Asio_INCLUDE_DIR}
     )
 target_link_libraries(DataReaderTests fastdds fastcdr foonathan_memory
     GTest::gmock
diff --git a/test/unittest/rtps/attributes/CMakeLists.txt b/test/unittest/rtps/attributes/CMakeLists.txt
index 0611da4d5c0..603cc2a877a 100644
--- a/test/unittest/rtps/attributes/CMakeLists.txt
+++ b/test/unittest/rtps/attributes/CMakeLists.txt
@@ -36,3 +36,61 @@ target_link_libraries(
     ${CMAKE_DL_LIBS})
 
 gtest_discover_tests(${THREAD_SETTINGS_TESTS_EXEC})
+
+if(EPROSIMA_TEST_DNS_NOT_SET_UP)
+    set(dns_filter "*ServerClientEnvironmentSetUpDNS*")
+endif()
+
+string(JOIN ":" SERVER_ATTRIBUTES_IGNORED_TESTS ${pkcs_filter} ${dns_filter})
+if(NOT SERVER_ATTRIBUTES_IGNORED_TESTS STREQUAL "")
+	message(STATUS "Ignoring tests '${SERVER_ATTRIBUTES_IGNORED_TESTS}'")
+    string(PREPEND SERVER_ATTRIBUTES_IGNORED_TESTS "-")
+endif()
+message(STATUS "SERVER_ATTRIBUTES_IGNORED_TESTS set to '${SERVER_ATTRIBUTES_IGNORED_TESTS}'")
+
+set(SERVER_ATTRIBUTES_TESTS_EXEC ServerAttributesTests)
+
+set(SERVER_ATTRIBUTES_TESTS_SOURCE
+    ServerAttributesTests.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ServerAttributes.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/common/GuidPrefix_t.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/common/LocatorWithMask.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/common/Time_t.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/network/utils/network.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/utils/IPFinder.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/utils/IPLocator.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/utils/md5.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/utils/SystemInfo.cpp
+    )
+
+add_executable(${SERVER_ATTRIBUTES_TESTS_EXEC} ${SERVER_ATTRIBUTES_TESTS_SOURCE})
+target_compile_definitions(${SERVER_ATTRIBUTES_TESTS_EXEC} PRIVATE
+    BOOST_ASIO_STANDALONE
+    ASIO_STANDALONE
+    $<$<AND:$<NOT:$<BOOL:${WIN32}>>,$<STREQUAL:"${CMAKE_BUILD_TYPE}","Debug">>:__DEBUG>
+    $<$<BOOL:${INTERNAL_DEBUG}>:__INTERNALDEBUG> # Internal debug activated.
+    )
+target_include_directories( ${SERVER_ATTRIBUTES_TESTS_EXEC} PRIVATE
+    ${Asio_INCLUDE_DIR}
+    ${PROJECT_SOURCE_DIR}/include
+    ${PROJECT_BINARY_DIR}/include
+    ${PROJECT_SOURCE_DIR}/src/cpp
+    )
+
+target_link_libraries(
+    ${SERVER_ATTRIBUTES_TESTS_EXEC}
+    GTest::gtest
+    ${CMAKE_DL_LIBS})
+
+if(MSVC OR MSVC_IDE)
+    target_link_libraries(${SERVER_ATTRIBUTES_TESTS_EXEC} ${PRIVACY} fastcdr iphlpapi Shlwapi ws2_32 fastdds::log)
+else()
+    target_link_libraries(${SERVER_ATTRIBUTES_TESTS_EXEC} ${PRIVACY} fastcdr fastdds::log)
+endif()
+
+gtest_discover_tests(${SERVER_ATTRIBUTES_TESTS_EXEC}
+    TEST_PREFIX "ServerAttributesTests."
+    TEST_FILTER ${SERVER_ATTRIBUTES_IGNORED_TESTS}
+    )
+
+unset(dns_filter)
diff --git a/test/unittest/rtps/attributes/ServerAttributesTests.cpp b/test/unittest/rtps/attributes/ServerAttributesTests.cpp
new file mode 100644
index 00000000000..79cebd1c697
--- /dev/null
+++ b/test/unittest/rtps/attributes/ServerAttributesTests.cpp
@@ -0,0 +1,471 @@
+// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
+//
+// Licensed 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 <gtest/gtest.h>
+
+#include <rtps/attributes/ServerAttributes.hpp>
+
+// Port used if the ros environment variable doesn't specify one
+constexpr uint16_t DEFAULT_ROS2_SERVER_PORT = 11811;
+// Port used by default for tcp transport
+constexpr uint16_t DEFAULT_TCP_SERVER_PORT = 42100;
+
+//! Tests the server-client setup using environment variable works fine
+TEST(ServerAttributesTests, ServerClientEnvironmentSetUp)
+{
+    using namespace std;
+    using namespace eprosima::fastdds::rtps;
+
+    LocatorList_t output, standard;
+    Locator_t loc, loc6(LOCATOR_KIND_UDPv6, 0);
+
+    // We are going to use several test string and check they are properly parsed and turn into RemoteServerList_t
+    // 1. Single server address without specific port provided
+    string text = "192.168.36.34";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc, text);
+    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 2. Single server IPv6 address without specific port provided
+    text = "2a02:26f0:dd:499::356e";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc6, text);
+    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 3. Single server address specifying a custom listening port
+    text = "192.168.36.34:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc, text);
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 4. Single server IPv6 address specifying a custom listening port
+    text = "[2001:470:142:5::116]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc6, "2001:470:142:5::116");
+    IPLocator::setPhysicalPort(loc6, 14520);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 5. Check any locator is turned into localhost
+    text = "0.0.0.0:14520;[::]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc, "127.0.0.1");
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    IPLocator::setIPv6(loc6, "::1");
+    IPLocator::setPhysicalPort(loc6, 14520);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 6. Check empty string scenario is handled
+    text = "";
+    output.clear();
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_TRUE(output.empty());
+
+    // 7. Check at least one server be present scenario is handled
+    text = ";;;;";
+    output.clear();
+
+    ASSERT_FALSE(load_environment_server_info(text, output));
+
+    // 8. Check several server scenario
+    text = "192.168.36.34:14520;172.29.55.77:8783;172.30.80.1:31090";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, string("192.168.36.34"));
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    IPLocator::setIPv4(loc, string("172.29.55.77"));
+    IPLocator::setPhysicalPort(loc, 8783);
+    standard.push_back(loc);
+
+    IPLocator::setIPv4(loc, string("172.30.80.1"));
+    IPLocator::setPhysicalPort(loc, 31090);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 9. Check several server scenario with IPv6 addresses too
+    text = "192.168.36.34:14520;[2a02:ec80:600:ed1a::3]:8783;172.30.80.1:31090";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, "192.168.36.34");
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    IPLocator::setIPv6(loc6, "2a02:ec80:600:ed1a::3");
+    IPLocator::setPhysicalPort(loc6, 8783);
+    standard.push_back(loc6);
+
+    IPLocator::setIPv4(loc, string("172.30.80.1"));
+    IPLocator::setPhysicalPort(loc, 31090);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 10. Check multicast addresses are identified as such
+    text = "239.255.0.1;ff1e::ffff:efff:1";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, "239.255.0.1");
+    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc);
+
+    IPLocator::setIPv6(loc6, "ff1e::ffff:efff:1");
+    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 11. Check ignore some servers scenario
+    text = ";192.168.36.34:14520;;172.29.55.77:8783;172.30.80.1:31090;";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, string("192.168.36.34"));
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    IPLocator::setIPv4(loc, string("172.29.55.77"));
+    IPLocator::setPhysicalPort(loc, 8783);
+    standard.push_back(loc);
+
+    IPLocator::setIPv4(loc, string("172.30.80.1"));
+    IPLocator::setPhysicalPort(loc, 31090);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 12. Check addresses as dns name (test domain urls are checked on a specific test)
+    text = "localhost.test:12345";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, "127.0.0.1");
+    IPLocator::setPhysicalPort(loc, 12345);
+    standard.push_back(loc);
+    IPLocator::setIPv6(loc6, "::1");
+    IPLocator::setPhysicalPort(loc6, 12345);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 13. Check mixed scenario with addresses and dns
+    text = "192.168.36.34:14520;localhost.test:12345;172.30.80.1:31090;";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, string("192.168.36.34"));
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    IPLocator::setIPv4(loc, string("127.0.0.1"));
+    IPLocator::setPhysicalPort(loc, 12345);
+    standard.push_back(loc);
+    IPLocator::setIPv6(loc6, string("::1"));
+    IPLocator::setPhysicalPort(loc6, 12345);
+    standard.push_back(loc6);
+
+    IPLocator::setIPv4(loc, string("172.30.80.1"));
+    IPLocator::setPhysicalPort(loc, 31090);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // TCP transport
+
+    Locator_t loc_tcp(LOCATOR_KIND_TCPv4, 0);
+    Locator_t loc_tcp_6(LOCATOR_KIND_TCPv6, 0);
+
+    // 14. Single TCPv4 address without specifying a custom listening port
+
+    text = "TCPv4:[192.168.36.34]";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc_tcp, "192.168.36.34");
+    IPLocator::setPhysicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
+    IPLocator::setLogicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
+    standard.push_back(loc_tcp);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 15. Single TCPv6 address without specifying a custom listening port
+
+    text = "TCPv6:[2a02:26f0:dd:499::356e]";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc_tcp_6, "2a02:26f0:dd:499::356e");
+    IPLocator::setPhysicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
+    IPLocator::setLogicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
+    standard.push_back(loc_tcp_6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 16. Single TCPv4 address specifying a custom listening port
+
+    text = "TCPv4:[192.168.36.34]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc_tcp, "192.168.36.34");
+    IPLocator::setPhysicalPort(loc_tcp, 14520);
+    IPLocator::setLogicalPort(loc_tcp, 14520);
+    standard.push_back(loc_tcp);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 17. Single TCPv6 address specifying a custom listening port
+
+    text = "TCPv6:[2a02:26f0:dd:499::356e]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc_tcp_6, "2a02:26f0:dd:499::356e");
+    IPLocator::setPhysicalPort(loc_tcp_6, 14520);
+    IPLocator::setLogicalPort(loc_tcp_6, 14520);
+    standard.push_back(loc_tcp_6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+}
+
+//! Tests the server-client setup using environment variable works fine using DNS
+TEST(ServerAttributesTests, ServerClientEnvironmentSetUpDNS)
+{
+    using namespace std;
+    using namespace eprosima::fastdds::rtps;
+
+    LocatorList_t output, standard;
+    Locator_t loc, loc6(LOCATOR_KIND_UDPv6, 0);
+
+    Locator_t loc_tcp(LOCATOR_KIND_TCPv4, 0);
+    Locator_t loc_tcp_6(LOCATOR_KIND_TCPv6, 0);
+
+    // 1. single server DNS address resolution without specific port provided
+    std::string text = "www.acme.com.test";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc6);
+    IPLocator::setIPv4(loc, "216.58.215.164");
+    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 2. single server DNS address specifying a custom listening port
+    text = "www.acme.com.test:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc6, 14520);
+    standard.push_back(loc6);
+    IPLocator::setIPv4(loc, "216.58.215.164");
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 3. single server DNS address specifying a custom locator type
+    // UDPv4
+    text = "UDPv4:[www.acme.com.test]";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc, "216.58.215.164");
+    IPLocator::setPhysicalPort(loc, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // UDPv6
+    text = "UDPv6:[www.acme.com.test]";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc6, DEFAULT_ROS2_SERVER_PORT);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // TCPv4
+    text = "TCPv4:[www.acme.com.test]";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc_tcp, "216.58.215.164");
+    IPLocator::setPhysicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
+    IPLocator::setLogicalPort(loc_tcp, DEFAULT_TCP_SERVER_PORT);
+    standard.push_back(loc_tcp);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // TCPv6
+    text = "TCPv6:[www.acme.com.test]";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc_tcp_6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
+    IPLocator::setLogicalPort(loc_tcp_6, DEFAULT_TCP_SERVER_PORT);
+    standard.push_back(loc_tcp_6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // 4. single server DNS address specifying a custom locator type and listening port
+    // UDPv4
+    text = "UDPv4:[www.acme.com.test]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc, "216.58.215.164");
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // UDPv6
+    text = "UDPv6:[www.acme.com.test]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc6, 14520);
+    standard.push_back(loc6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // TCPv4
+    text = "TCPv4:[www.acme.com.test]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv4(loc_tcp, "216.58.215.164");
+    IPLocator::setPhysicalPort(loc_tcp, 14520);
+    IPLocator::setLogicalPort(loc_tcp, 14520);
+    standard.push_back(loc_tcp);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // TCPv6
+    text = "TCPv6:[www.acme.com.test]:14520";
+
+    output.clear();
+    standard.clear();
+    IPLocator::setIPv6(loc_tcp_6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc_tcp_6, 14520);
+    IPLocator::setLogicalPort(loc_tcp_6, 14520);
+    standard.push_back(loc_tcp_6);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+
+    // SHM Locator kind should fail
+    text = "SHM:[www.acme.com.test]";
+
+    output.clear();
+    ASSERT_FALSE(load_environment_server_info(text, output));
+
+    // 5. Check mixed scenario with addresses and dns
+    text = "192.168.36.34:14520;UDPv6:[www.acme.com.test]:14520;172.30.80.1:31090;";
+
+    output.clear();
+    standard.clear();
+
+    IPLocator::setIPv4(loc, string("192.168.36.34"));
+    IPLocator::setPhysicalPort(loc, 14520);
+    standard.push_back(loc);
+
+    IPLocator::setIPv6(loc6, "2a00:1450:400e:803::2004");
+    IPLocator::setPhysicalPort(loc6, 14520);
+    standard.push_back(loc6);
+
+    IPLocator::setIPv4(loc, string("172.30.80.1"));
+    IPLocator::setPhysicalPort(loc, 31090);
+    standard.push_back(loc);
+
+    ASSERT_TRUE(load_environment_server_info(text, output));
+    ASSERT_EQ(output, standard);
+}
+
+int main(
+        int argc,
+        char** argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/test/unittest/rtps/attributes/ThreadSettingsTests.cpp b/test/unittest/rtps/attributes/ThreadSettingsTests.cpp
index 8abce8ff719..b5aa1198a42 100644
--- a/test/unittest/rtps/attributes/ThreadSettingsTests.cpp
+++ b/test/unittest/rtps/attributes/ThreadSettingsTests.cpp
@@ -142,8 +142,10 @@ TEST(ThreadSettingsTests, EqualOperators)
     ASSERT_TRUE(settings_1 != settings_2);
 }
 
-int main()
+int main(
+        int argc,
+        char** argv)
 {
-    testing::InitGoogleTest();
+    testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }
diff --git a/test/unittest/rtps/reader/CMakeLists.txt b/test/unittest/rtps/reader/CMakeLists.txt
index 1cd1a450b40..f97299fcc02 100644
--- a/test/unittest/rtps/reader/CMakeLists.txt
+++ b/test/unittest/rtps/reader/CMakeLists.txt
@@ -174,6 +174,7 @@ set(STATEFUL_READER_TESTS_SOURCE StatefulReaderTests.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/EndpointSecurityAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/PropertyPolicy.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
+    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ServerAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ThreadSettings.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/BuiltinProtocols.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/ParticipantProxyData.cpp
@@ -199,7 +200,6 @@ set(STATEFUL_READER_TESTS_SOURCE StatefulReaderTests.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
-    ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
     ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/liveliness/WLP.cpp
diff --git a/test/unittest/statistics/dds/CMakeLists.txt b/test/unittest/statistics/dds/CMakeLists.txt
index b08d33f54ec..9fab90374cf 100644
--- a/test/unittest/statistics/dds/CMakeLists.txt
+++ b/test/unittest/statistics/dds/CMakeLists.txt
@@ -180,6 +180,7 @@ if (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/EndpointSecurityAttributes.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/PropertyPolicy.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/RTPSParticipantAttributes.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ServerAttributes.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ThreadSettings.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/BuiltinProtocols.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/ParticipantProxyData.cpp
@@ -205,7 +206,6 @@ if (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
-        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/liveliness/WLP.cpp
@@ -358,6 +358,7 @@ if (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
         ${PROJECT_SOURCE_DIR}/src/cpp/fastdds/utils/QosConverters.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/EndpointSecurityAttributes.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/PropertyPolicy.cpp
+        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ServerAttributes.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/attributes/ThreadSettings.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/BuiltinProtocols.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/data/ParticipantProxyData.cpp
@@ -383,7 +384,6 @@ if (SQLITE3_SUPPORT AND FASTDDS_STATISTICS AND NOT QNX)
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServer.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPServerListener.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/PDPSimple.cpp
-        ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/ServerAttributes.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DSClientEvent.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/discovery/participant/timedevent/DServerEvent.cpp
         ${PROJECT_SOURCE_DIR}/src/cpp/rtps/builtin/liveliness/WLP.cpp
diff --git a/test/unittest/utils/LocatorTests.cpp b/test/unittest/utils/LocatorTests.cpp
index 070843a2f78..44425d18684 100644
--- a/test/unittest/utils/LocatorTests.cpp
+++ b/test/unittest/utils/LocatorTests.cpp
@@ -1724,6 +1724,16 @@ TEST(RemoteLocatorsTests, RemoteLocator_deserialization)
     serialized_ss >> rll;
     ASSERT_EQ(rll.multicast.size(), 2u);
     ASSERT_EQ(rll.unicast.size(), 2u);
+    Locator_t loc_test2;
+    IPLocator::createLocator(LOCATOR_KIND_UDPv4, "239.255.255.255", 2, loc_test2);
+    Locator_t loc_test3;
+    IPLocator::createLocator(LOCATOR_KIND_UDPv4, "1.2.3.4", 3, loc_test3);
+    Locator_t loc_test4;
+    IPLocator::createLocator(LOCATOR_KIND_UDPv4, "4.3.2.1", 4, loc_test4);
+    ASSERT_EQ(rll.multicast[0], locator);
+    ASSERT_EQ(rll.multicast[1], loc_test2);
+    ASSERT_EQ(rll.unicast[0], loc_test3);
+    ASSERT_EQ(rll.unicast[1], loc_test4);
 
     // Check error List
     serialized_ss.clear();
diff --git a/test/unittest/utils/SystemInfoTests.cpp b/test/unittest/utils/SystemInfoTests.cpp
index f8cbedcbdda..13216b1ca23 100644
--- a/test/unittest/utils/SystemInfoTests.cpp
+++ b/test/unittest/utils/SystemInfoTests.cpp
@@ -32,7 +32,7 @@
 #include <gtest/gtest.h>
 #include <nlohmann/json.hpp>
 
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
+#include <rtps/attributes/ServerAttributes.hpp>
 #include <utils/SystemInfo.hpp>
 
 #define SIZE 512
diff --git a/test/unittest/xmlparser/XMLElementParserTests.cpp b/test/unittest/xmlparser/XMLElementParserTests.cpp
index f31721b89b1..10730e94866 100644
--- a/test/unittest/xmlparser/XMLElementParserTests.cpp
+++ b/test/unittest/xmlparser/XMLElementParserTests.cpp
@@ -906,108 +906,6 @@ TEST_F(XMLParserTests, getXMLPropertiesPolicy)
     EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::propertiesPolicy_wrapper(titleElement, property_policy, ident));
 }
 
-/*
- * This test checks the proper parsing of a <RemoteServer> xml element to a RemoteServerAttributes object, and negative
- * cases.
- * 1. Check nullptr as tinyxml2::XMLElement argument.
- * 2. Check missing prefix in the <RemoteServer> tag.
- * 3. Check wrongly formated in the <RemoteServer> tag.
- * 5. Check an empty <metatrafficUnicastLocatorList> tag.
- * 6. Check an empty <metatrafficMulticastLocatorList> tag.
- * 6. Check a <RemoteServer> tag with no locators.
- */
-TEST_F(XMLParserTests, getXMLRemoteServer)
-{
-    uint8_t ident = 1;
-    RemoteServerAttributes attr;
-    tinyxml2::XMLDocument xml_doc;
-    tinyxml2::XMLElement* titleElement;
-
-    const std::vector<std::string> valid_parameters {
-        "prefix=\"4D.49.47.55.45.4c.5f.42.41.52.52.4f\"",
-        "<locator>\
-            <udpv6>\
-                <port>8844</port>\
-                <address>::1</address>\
-            </udpv6>\
-        </locator>",
-        "<locator>\
-            <udpv6>\
-                <port>8844</port>\
-                <address>::1</address>\
-            </udpv6>\
-        </locator>", };
-    std::vector<std::string> parameters(valid_parameters);
-
-    // Parametrized XML
-    const char* xml_p =
-            "\
-            <RemoteServer %s>\
-                    <metatrafficUnicastLocatorList>%s</metatrafficUnicastLocatorList>\
-                    <metatrafficMulticastLocatorList>%s</metatrafficMulticastLocatorList>\
-            </RemoteServer>\
-            ";
-    constexpr size_t xml_len {1200};
-    char xml[xml_len];
-
-    // Valid XML
-    snprintf(xml, xml_len, xml_p, valid_parameters[0].c_str(), valid_parameters[1].c_str(),
-            valid_parameters[2].c_str());
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    ASSERT_EQ(XMLP_ret::XML_OK, XMLParserTest::getXMLRemoteServer_wrapper(titleElement, attr, ident));
-    EXPECT_EQ(attr.guidPrefix.value[0], (octet)0x4d);
-    EXPECT_EQ(attr.guidPrefix.value[1], (octet)0x49);
-    EXPECT_EQ(attr.guidPrefix.value[2], (octet)0x47);
-    EXPECT_EQ(attr.guidPrefix.value[3], (octet)0x55);
-    EXPECT_EQ(attr.guidPrefix.value[4], (octet)0x45);
-    EXPECT_EQ(attr.guidPrefix.value[5], (octet)0x4c);
-    EXPECT_EQ(attr.guidPrefix.value[6], (octet)0x5f);
-    EXPECT_EQ(attr.guidPrefix.value[7], (octet)0x42);
-    EXPECT_EQ(attr.guidPrefix.value[8], (octet)0x41);
-    EXPECT_EQ(attr.guidPrefix.value[9], (octet)0x52);
-    EXPECT_EQ(attr.guidPrefix.value[10], (octet)0x52);
-    EXPECT_EQ(attr.guidPrefix.value[11], (octet)0x4f);
-
-    EXPECT_EQ(attr.metatrafficUnicastLocatorList.begin()->port, 8844u);
-    EXPECT_EQ(attr.metatrafficUnicastLocatorList.begin()->address[15], 1);
-    EXPECT_EQ(attr.metatrafficMulticastLocatorList.begin()->port, 8844u);
-    EXPECT_EQ(attr.metatrafficMulticastLocatorList.begin()->address[15], 1);
-
-    // nullptr element
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLRemoteServer_wrapper(nullptr, attr, ident));
-
-    // No prefix
-    snprintf(xml, xml_len, xml_p, "", valid_parameters[1].c_str(), valid_parameters[2].c_str());
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLRemoteServer_wrapper(titleElement, attr, ident));
-
-    // Bad prefix value
-    snprintf(xml, xml_len, xml_p, "prefix=\"\"", valid_parameters[1].c_str(), valid_parameters[2].c_str());
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLRemoteServer_wrapper(titleElement, attr, ident));
-
-    // Bad unicast
-    snprintf(xml, xml_len, xml_p, valid_parameters[0].c_str(), "", valid_parameters[2].c_str());
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLRemoteServer_wrapper(titleElement, attr, ident));
-
-    // Bad multicast
-    snprintf(xml, xml_len, xml_p, valid_parameters[0].c_str(), valid_parameters[1].c_str(), "");
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLRemoteServer_wrapper(titleElement, attr, ident));
-
-    // No locators
-    snprintf(xml, xml_len, "<RemoteServer %s></RemoteServer>", valid_parameters[0].c_str());
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLRemoteServer_wrapper(titleElement, attr, ident));
-}
-
 /*
  * This test checks the negative cases of a <port> xml element.
  * 1. Check a missing case of each of the <port> child tags.
@@ -1331,73 +1229,6 @@ TEST_F(XMLParserTests, getXMLString)
     EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLString_wrapper(titleElement, &s, ident));
 }
 
-/*
- * This test checks the negative cases of the XMLParser::getXMLList method.
- * 1. Check passing a nullptr as a tinyxml2::XMLElement argument.
- * 2. Check passing an empty <list> field.
- * 3. Check passing a non valid value of <RemoteServer> descriptor as an element of <list>.
- */
-TEST_F(XMLParserTests, getXMLList_NegativeClauses)
-{
-    uint8_t ident = 1;
-    RemoteServerList_t list;
-    tinyxml2::XMLDocument xml_doc;
-    tinyxml2::XMLElement* titleElement;
-
-    // empty element
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLList_wrapper(nullptr, list, ident));
-
-    // empty list
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse("<list></list>"));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLList_wrapper(titleElement, list, ident));
-
-    // bad remote server element
-    const char* xml = "<list><RemoteServer>bad_remote_server</RemoteServer></list>";
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_ERROR, XMLParserTest::getXMLList_wrapper(titleElement, list, ident));
-}
-
-/*
- * This test checks the positive case of the XMLParser::getXMLList method.
- * 1. Check an valid return on the function.
- * 2. Check the correct element has been placed on the list.
- */
-TEST_F(XMLParserTests, getXMLList_positive)
-{
-    uint8_t ident = 1;
-    RemoteServerList_t list;
-    tinyxml2::XMLDocument xml_doc;
-    tinyxml2::XMLElement* titleElement;
-
-    // bad remote server element
-    const char* xml =
-            "<list>\
-                <RemoteServer prefix=\"4D.49.47.55.45.4c.5f.42.41.52.52.4f\">\
-                            <metatrafficUnicastLocatorList>\
-                                <locator>\
-                                    <udpv6>\
-                                        <port>8844</port>\
-                                        <address>::1</address>\
-                                    </udpv6>\
-                                </locator>\
-                            </metatrafficUnicastLocatorList>\
-                </RemoteServer>\
-            </list>";
-
-    ASSERT_EQ(tinyxml2::XMLError::XML_SUCCESS, xml_doc.Parse(xml));
-    titleElement = xml_doc.RootElement();
-    EXPECT_EQ(XMLP_ret::XML_OK, XMLParserTest::getXMLList_wrapper(titleElement, list, ident));
-    EXPECT_EQ(list.begin()->metatrafficUnicastLocatorList.begin()->port, 8844u);
-    EXPECT_EQ(list.begin()->metatrafficUnicastLocatorList.begin()->address[15], 1);
-    EXPECT_EQ(list.begin()->guidPrefix.value[0], 0x4d);
-    EXPECT_EQ(list.begin()->guidPrefix.value[1], 0x49);
-    EXPECT_EQ(list.begin()->guidPrefix.value[2], 0x47);
-    EXPECT_EQ(list.begin()->guidPrefix.value[3], 0x55);
-    EXPECT_EQ(list.begin()->guidPrefix.value[4], 0x45);
-}
-
 /*
  * This test checks the negative cases of the XMLParser::getXMLBool method.
  * 1. Check passing a nullptr as a tinyxml2::XMLElement argument.
diff --git a/test/unittest/xmlparser/wrapper/XMLParserTest.hpp b/test/unittest/xmlparser/wrapper/XMLParserTest.hpp
index 46b8499b72b..a0de6da9eb0 100644
--- a/test/unittest/xmlparser/wrapper/XMLParserTest.hpp
+++ b/test/unittest/xmlparser/wrapper/XMLParserTest.hpp
@@ -140,14 +140,6 @@ class XMLParserTest : public XMLParser
         return getXMLPropertiesPolicy(elem, propertiesPolicy, ident);
     }
 
-    static XMLP_ret getXMLRemoteServer_wrapper(
-            tinyxml2::XMLElement* elem,
-            RemoteServerAttributes& attr,
-            uint8_t ident)
-    {
-        return getXMLRemoteServer(elem, attr, ident);
-    }
-
     static XMLP_ret getXMLTransports_wrapper(
             tinyxml2::XMLElement* elem,
             std::vector<std::shared_ptr<eprosima::fastdds::rtps::TransportDescriptorInterface>>& transports,
@@ -189,14 +181,6 @@ class XMLParserTest : public XMLParser
         return getXMLString(elem, s, ident);
     }
 
-    static XMLP_ret getXMLList_wrapper(
-            tinyxml2::XMLElement* elem,
-            eprosima::fastdds::rtps::RemoteServerList_t& list,
-            uint8_t ident)
-    {
-        return getXMLList(elem, list, ident);
-    }
-
     static XMLP_ret getXMLBool_wrapper(
             tinyxml2::XMLElement* elem,
             bool* b,
diff --git a/tools/fastdds/discovery/parser.py b/tools/fastdds/discovery/parser.py
index 8354a47177c..8446698e89e 100644
--- a/tools/fastdds/discovery/parser.py
+++ b/tools/fastdds/discovery/parser.py
@@ -30,8 +30,6 @@
 class Parser:
     """Discovery server tool parser."""
 
-    __help_message = 'fastdds discovery <discovery-args>\n\n'
-
     def __init__(self, argv):
         """
         Parse the sub-command and dispatch to the appropriate handler.
@@ -43,7 +41,7 @@ def __init__(self, argv):
 
         try:
             result = subprocess.run(
-                [tool_path],
+                [tool_path, '-h'],
                 stdout=subprocess.PIPE,
                 universal_newlines=True
             )
@@ -52,7 +50,6 @@ def __init__(self, argv):
                 sys.exit(result.returncode)
 
             if (
-                    len(argv) == 0 or
                     (len(argv) == 1 and argv[0] == '-h') or
                     (len(argv) == 1 and argv[0] == '--help')
                ):
@@ -68,9 +65,7 @@ def __init__(self, argv):
             pass
 
         except BaseException as e:
-            self.__help_message += str(e)
-            self.__help_message += '\n fast-discovery-server tool not found!'
-            print(self.__help_message)
+            print('\n fast-discovery-server tool not found!')
             sys.exit(1)
 
     def __find_tool_path(self):
diff --git a/tools/fds/server.cpp b/tools/fds/server.cpp
index 2addf820910..a0ea8a5b55b 100644
--- a/tools/fds/server.cpp
+++ b/tools/fds/server.cpp
@@ -21,14 +21,13 @@
 #include <regex>
 #include <sstream>
 #include <stdlib.h>
-#include <string>
 #include <vector>
 
 #include <fastdds/dds/domain/DomainParticipant.hpp>
 #include <fastdds/dds/domain/DomainParticipantFactory.hpp>
 #include <fastdds/dds/domain/qos/DomainParticipantQos.hpp>
 #include <fastdds/dds/log/Log.hpp>
-#include <fastdds/rtps/attributes/ServerAttributes.hpp>
+#include <fastdds/rtps/attributes/RTPSParticipantAttributes.hpp>
 #include <fastdds/rtps/common/Locator.hpp>
 #include <fastdds/rtps/transport/UDPv6TransportDescriptor.hpp>
 #include <fastdds/rtps/transport/TCPv6TransportDescriptor.hpp>
@@ -78,6 +77,13 @@ int fastdds_discovery_server(
         return 1;
     }
 
+    for (option::Option* opt = options[UNKNOWN]; opt; opt = opt->next())
+    {
+        EPROSIMA_LOG_ERROR(CLI, "Unknown option: " << opt->name);
+        option::printUsage(std::cout, usage);
+        return 1;
+    }
+
     // No arguments beyond options
     int noopts = parse.nonOptionsCount();
     if (noopts)
@@ -96,9 +102,10 @@ int fastdds_discovery_server(
     }
 
     // Show help if asked to
-    if (options[HELP] || argc == 0)
+    if (options[HELP])
     {
         option::printUsage(std::cout, usage);
+        std::cout << EXAMPLES << std::endl;
         return 0;
     }
 
@@ -165,29 +172,33 @@ int fastdds_discovery_server(
 
     }
 
-    // Retrieve server Id: is mandatory and only specified once
+    // Retrieve server ID: is optional and only specified once
     // Note there is a specific cast to pointer if the Option is valid
     option::Option* pOp = options[SERVERID];
-    int server_id = 0;
+    int server_id = -1;
+    std::stringstream server_stream;
 
     if (nullptr == pOp)
     {
         fastdds::rtps::GuidPrefix_t prefix_cero;
-        if (participantQos.wire_protocol().prefix == prefix_cero)
-        {
-            std::cout << "Server id is mandatory if not defined in the XML file: use -i or --server-id option." <<
-                std::endl;
-            return 1;
-        }
-        else if (!(participantQos.wire_protocol().builtin.discovery_config.discoveryProtocol ==
+        if (!(participantQos.wire_protocol().builtin.discovery_config.discoveryProtocol ==
                 eprosima::fastdds::rtps::DiscoveryProtocol::SERVER ||
                 participantQos.wire_protocol().builtin.discovery_config.discoveryProtocol ==
-                eprosima::fastdds::rtps::DiscoveryProtocol::BACKUP))
+                eprosima::fastdds::rtps::DiscoveryProtocol::BACKUP) && nullptr != options[XML_FILE])
         {
+            // Discovery protocol specified in XML file is not SERVER nor BACKUP
             std::cout << "The provided configuration is not valid. Participant must be either SERVER or BACKUP. " <<
                 std::endl;
             return 1;
         }
+        else if (participantQos.wire_protocol().prefix == prefix_cero &&
+                participantQos.wire_protocol().builtin.discovery_config.discoveryProtocol ==
+                eprosima::fastdds::rtps::DiscoveryProtocol::BACKUP)
+        {
+            // Discovery protocol specified in XML is BACKUP, but no GUID was specified
+            std::cout << "Specifying a GUID prefix is mandatory for BACKUP Discovery Servers." <<
+                "Update the XML file or use the -i argument." << std::endl;
+        }
     }
     else if (pOp->count() != 1)
     {
@@ -196,32 +207,40 @@ int fastdds_discovery_server(
     }
     else
     {
-        std::stringstream is;
-        is << pOp->arg;
-
-        // Validation has been already done
-        // Name the server according with the identifier
-        if (!(is >> server_id
-                && eprosima::fastdds::rtps::get_server_client_default_guidPrefix(server_id,
-                participantQos.wire_protocol().prefix)))
+        // Cast of option to int has already been checked
+        server_stream << pOp->arg;
+        server_stream >> server_id;
+        if (!eprosima::fastdds::rtps::get_server_client_default_guidPrefix(server_id,
+                participantQos.wire_protocol().prefix))
         {
-            std::cout << "The provided server identifier is not valid" << std::endl;
+            std::cout << "Failed to set the GUID with the server identifier provided." << std::endl;
             return 1;
         }
+    }
 
-        // Clear the std::stringstream state and reset it to an empty string
-        is.clear();
-        is.str("");
+    // Clear the std::stringstream state and reset it to an empty string
+    server_stream.clear();
+    server_stream.str("");
 
-        // Set Participant Name
-        is << "eProsima Default Server number " << server_id;
-        participantQos.name(is.str().c_str());
-    }
+    // Set Participant Name
+    std::string server_name =
+            (server_id == -1) ? "eProsima Guidless Server" : "eProsima Default Server" + std::to_string(
+        server_id);
+    server_stream << server_name;
+    participantQos.name(server_stream.str().c_str());
 
     // Choose the kind of server to create
     pOp = options[BACKUP];
     if (nullptr != pOp)
     {
+        fastdds::rtps::GuidPrefix_t prefix_cero;
+        if (participantQos.wire_protocol().prefix == prefix_cero && server_id == -1)
+        {
+            // BACKUP argument used, but no GUID was specified either in the XML nor in the CLI
+            std::cout << "Specifying a GUID prefix is mandatory for BACKUP Discovery Servers. Use the -i argument." <<
+                std::endl;
+            return 1;
+        }
         participantQos.wire_protocol().builtin.discovery_config.discoveryProtocol = DiscoveryProtocol::BACKUP;
     }
     else if (nullptr == options[XML_FILE])
@@ -254,10 +273,6 @@ int fastdds_discovery_server(
     option::Option* pO_port = options[UDP_PORT];
     if (nullptr != pO_port)
     {
-        // if (eprosima::fastdds::dds::check_udp_port(*pO_port, true) != option::ARG_OK)
-        // {
-        //     return 1;
-        // }
         std::stringstream is;
         is << pO_port->arg;
         uint16_t id;
@@ -277,7 +292,15 @@ int fastdds_discovery_server(
 
     // Retrieve first IP address
     pOp = options[UDPADDRESS];
+    if (pOp != nullptr && pOp->arg == nullptr)
+    {
+        pOp->arg = "0.0.0.0";
+    }
     option::Option* pO_tcp = options[TCPADDRESS];
+    if (pO_tcp != nullptr && pO_tcp->arg == nullptr)
+    {
+        pO_tcp->arg = "0.0.0.0";
+    }
     // Retrieve first TCP port
     option::Option* pO_tcp_port = options[TCP_PORT];
 
@@ -380,7 +403,7 @@ int fastdds_discovery_server(
             else
             {
                 std::cout << "Warning: the number of specified ports doesn't match the ip" << std::endl
-                          << "         addresses provided. Locators share its port number." << std::endl;
+                          << "         addresses provided. Locators share their port number." << std::endl;
             }
         }
 
@@ -431,9 +454,12 @@ int fastdds_discovery_server(
     {
         if (nullptr == pO_tcp)
         {
-            // Only the TCP port has been specified. Use localhost as default interface for TCP
-            IPLocator::setIPv4(locator_tcp_4, "127.0.0.1");
+            // Only the TCP port has been specified. Use "any" as interface for TCP to listen on all interfaces
+            IPLocator::setIPv4(locator_tcp_4, "0.0.0.0");
             participantQos.wire_protocol().builtin.metatrafficUnicastLocatorList.push_back(locator_tcp_4);
+            auto tcp_descriptor = std::make_shared<eprosima::fastdds::rtps::TCPv4TransportDescriptor>();
+            tcp_descriptor->add_listener_port(static_cast<uint16_t>(locator_tcp_4.port));
+            participantQos.transport().user_transports.push_back(tcp_descriptor);
         }
         else if (nullptr != pO_tcp)
         {
@@ -577,10 +603,7 @@ int fastdds_discovery_server(
             participantQos.wire_protocol().builtin.discovery_config.discoveryProtocol <<
             std::endl;
         std::cout << "  Security:           " << (has_security ? "YES" : "NO") << std::endl;
-        std::cout << "  Server ID:          " << server_id << std::endl;
-        std::cout << "  Server GUID prefix: " <<
-            (has_security ? participantQos.wire_protocol().prefix : pServer->guid().guidPrefix) <<
-            std::endl;
+        std::cout << "  Server GUID prefix: " << pServer->guid().guidPrefix << std::endl;
         std::cout << "  Server Addresses:   ";
         for (auto locator_it = participantQos.wire_protocol().builtin.metatrafficUnicastLocatorList.begin();
                 locator_it != participantQos.wire_protocol().builtin.metatrafficUnicastLocatorList.end();)
@@ -643,8 +666,8 @@ option::ArgStatus Arg::check_server_id(
 
     if (msg)
     {
-        std::cout << "Option '" << option.name
-                  << "' is mandatory. Should be a key identifier between 0 and 255." << std::endl;
+        std::cout << "\nOption '" << option.name
+                  << "' is optional. Should be a key identifier between 0 and 255." << std::endl;
     }
 
     return option::ARG_ILLEGAL;
@@ -662,7 +685,7 @@ option::ArgStatus Arg::required(
 
     if (msg)
     {
-        std::cout << "Option '" << option << "' requires an argument" << std::endl;
+        std::cout << "\nOption '" << option.desc->longopt << "' requires an argument." << std::endl;
     }
     return option::ARG_ILLEGAL;
 }
@@ -691,7 +714,7 @@ option::ArgStatus Arg::check_udp_port(
 
     if (msg)
     {
-        std::cout << "Option '" << option.name
+        std::cout << "\nOption '" << option.name
                   << "' value should be an UDP port between 1025 and 65535." << std::endl;
     }
 
@@ -721,7 +744,7 @@ option::ArgStatus Arg::check_tcp_port(
 
     if (msg)
     {
-        std::cout << "Option '" << option.name
+        std::cout << "\nOption '" << option.name
                   << "' value should be an TCP port between 1025 and 65535." << std::endl;
     }
 
diff --git a/tools/fds/server.h b/tools/fds/server.h
index 6e47e50846d..4f794c3755e 100644
--- a/tools/fds/server.h
+++ b/tools/fds/server.h
@@ -17,6 +17,7 @@
 
 // Parsing setup
 #include <optionparser.hpp>
+#include <string>
 
 namespace option = eprosima::option;
 
@@ -61,25 +62,21 @@ const option::Descriptor usage[] = {
     { HELP,      0, "h",  "help",         Arg::None,
       "  -h  \t--help        Produce help message.\n" },
 
-    { SERVERID,  0, "i", "server-id",    Arg::check_server_id,
-      "  -i \t--server-id   Unique server identifier. Specifies zero based server\n"
-      "\t              position in ROS_DISCOVERY_SERVER environment variable.\n" },
-
-    { UDPADDRESS, 0, "l", "udp-address",   Arg::required,
+    { UDPADDRESS, 0, "l", "udp-address",   Arg::OptionalAny,
       "  -l \t--udp-address IPv4/IPv6 address chosen to listen the clients. Defaults\n"
       "\t              to any (0.0.0.0/::0). Instead of an address, a name can\n"
       "\t              be specified.\n"},
 
     { UDP_PORT,  0, "p",  "udp-port",       Arg::check_udp_port,
-      "  -p  \t--udp-port    UDP port chosen to listen the clients. Defaults to 11811\n" },
+      "  -p  \t--udp-port    UDP port chosen to listen the clients. Defaults to 11811.\n" },
 
-    { TCPADDRESS, 0, "t", "tcp-address",   Arg::required,
+    { TCPADDRESS, 0, "t", "tcp-address",   Arg::OptionalAny,
       "  -t \t--tcp-address IPv4/IPv6 address chosen to listen the clients using\n"
       "\t              TCP transport. Defaults to any (0.0.0.0/::0). Instead of an \n"
       "\t              address, a name can be specified.\n"},
 
     { TCP_PORT,  0, "q",  "tcp-port",         Arg::check_tcp_port,
-      "  -q  \t--tcp-port    TCP port chosen to listen the clients. Defaults to 42100\n" },
+      "  -q  \t--tcp-port    TCP port chosen to listen the clients. Defaults to 42100.\n" },
 
     { BACKUP,    0, "b",  "backup",       Arg::None,
       "  -b  \t--backup      Creates a server with a backup file associated.\n" },
@@ -91,58 +88,58 @@ const option::Descriptor usage[] = {
       "\t              the profile with \"is_default_profile=\"true\"\" unless \n"
       "\t              another profile using uri with \"@\" character is defined.\n"},
 
-    { UNKNOWN,   0, "",  "",              Arg::None,
-      "Examples:\n"
-
-      "\t1.  Launch a default server with id 0 (first on ROS_DISCOVERY_SERVER)\n"
-      "\t    listening on all available interfaces on UDP port 11811. Only one\n"
-      "\t    server can use default values per machine.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 0\n\n"
-
-      "\t2.  Launch a default server with id 1 (second on ROS_DISCOVERY_SERVER)\n"
-      "\t    listening on localhost with UDP port 14520. Only localhost clients\n"
-      "\t    can reach the server using ROS_DISCOVERY_SERVER=;127.0.0.1:14520\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 1 -l 127.0.0.1 -p 14520\n\n"
-
-      "\t3.  Launch a default server with id 1 (second on ROS_DISCOVERY_SERVER)\n"
-      "\t    listening on UDPv6 address with UDP port 14520.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 1 -l 2a02:ec80:600:ed1a::3 -p 14520\n\n"
-
-      "\t4.  Launch a default server with id 2 (third on ROS_DISCOVERY_SERVER)\n"
-      "\t    listening on Wi-Fi (192.163.6.34) and Ethernet (172.20.96.1) local\n"
-      "\t    interfaces with UDP ports 8783 and 51083 respectively\n"
-      "\t    (addresses and ports are made up for the example).\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 2 -l 192.163.6.34 -p 8783 -l 172.20.96.1 -p 51083\n\n"
-
-      "\t5.  Launch a default server with id 3 (fourth on ROS_DISCOVERY_SERVER)\n"
-      "\t    listening on 172.31.44.1 with UDP port 12345 and provided with a\n"
-      "\t    backup file. If the server crashes it will automatically restore its\n"
-      "\t    previous state when reenacted.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 3 -l 172.31.44.1 -p 12345 -b\n\n"
-
-      "\t6.  Launch a default server with id 0 (first on ROS_DISCOVERY_SERVER)\n"
-      "\t    listening on localhost with UDP port 14520. Only localhost clients\n"
-      "\t    can reach the server using ROS_DISCOVERY_SERVER=localhost:14520\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 0 -l localhost -p 14520\n\n"
-
-      "\t7.  Launch a server with id 0 (first on ROS_DISCOVERY_SERVER) reading\n"
-      "\t    default configuration from XML file.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 0 -x config.xml\n\n"
-
-      "\t8.  Launch a server with id 0 (first on ROS_DISCOVERY_SERVER) reading\n"
-      "\t    specific profile_name configuration from XML file.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 0 -x profile_name@config.xml\n\n"
-
-      "\t9.  Launch a server with id 0 (first on ROS_DISCOVERY_SERVER) listening\n"
-      "\t    on localhost with default TCP port 42100.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 0 -t 127.0.0.1\n\n"
-
-      "\t10. Launch a server with id 0 (first on ROS_DISCOVERY_SERVER) listening\n"
-      "\t    on localhost and Wi-Fi (192.163.6.34). Two TCP ports need to be\n"
-      "\t    specified because TCP Transports cannot share ports.\n\n"
-      "\t    $ " FAST_SERVER_BINARY " -i 0 -t 127.0.0.1 -q 42100 -t 192.163.6.34 -q 42101"},
+    { SERVERID,  0, "i", "server-id",    Arg::check_server_id,
+      "  -i \t--server-id   Unique server identifier. Its functionality its\n"
+      "\t              deprecated. It can be used to select a fixed GUID.\n" },
 
     { 0, 0, 0, 0, 0, 0 }
 };
 
+const std::string EXAMPLES =
+
+        "Examples:\n"
+
+        "\t1.  Launch a default server listening on all available interfaces on\n"
+        "\t    UDP port 11811. Only one server can use default values per machine.\n\n"
+        "\t    $ " FAST_SERVER_BINARY "\n\n"
+
+        "\t2.  Launch a default server listening on localhost on UDP port 14520.\n"
+        "\t    Only localhost clients can reach the server, for example using\n"
+        "\t    ROS_DISCOVERY_SERVER=127.0.0.1:14520\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -l 127.0.0.1 -p 14520\n\n"
+
+        "\t3.  Launch a default server listening on all available interfaces on\n"
+        "\t    TCP port 42100. Only one server can use default values per machine.\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -t\n\n"
+
+        "\t4.  Launch a default server with GUID corresponding to id 1 (deprecated\n"
+        "\t    parameter) listening on IPv6 address on UDP port 14520.\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -i 1 -l 2a02:ec80:600:ed1a::3 -p 14520\n\n"
+
+        "\t5.  Launch a default server listening on WiFi (192.168.36.34) and Ethernet\n"
+        "\t    (172.20.96.1) local interfaces on UDP ports 8783 and 51083 \n"
+        "\t    respectively (addresses and ports are made up for the example).\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -l 192.163.6.34 -p 8783 -l 172.20.96.1\n"
+        "\t    -p 51083\n\n"
+
+        "\t6.  Launch a default server listening on 172.31.44.1 on UDP port 12345\n"
+        "\t    and provided with a backup file. If the server crashes it will\n"
+        "\t    automatically restore its previous state when reenacted.\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -l 172.31.44.1 -p 12345 -b\n\n"
+
+        "\t7.  Launch a server reading default configuration from XML file.\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -x config.xml\n\n"
+
+        "\t8.  Launch a server reading a profile_name configuration from XML file.\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -x profile_name@config.xml\n\n"
+
+        "\t9.  Launch a server listening on localhost with default TCP port 42100\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -t 127.0.0.1\n\n"
+
+        "\t10. Launch a server listening on localhost and Wi-Fi (192.163.6.34).\n"
+        "\t    Two TCP ports need to be specified because TCP Transports cannot\n"
+        "\t    share ports.\n\n"
+        "\t    $ " FAST_SERVER_BINARY " -t 127.0.0.1 -q 42100 -t 192.163.6.34 \n"
+        "\t    -q 42101";
+
 #endif // FASTDDS_SERVER_SERVER_H_
diff --git a/versions.md b/versions.md
index 7057c00d780..9e749ca7a2e 100644
--- a/versions.md
+++ b/versions.md
@@ -35,6 +35,7 @@ Forthcoming
   * ReaderLocator
   * ReaderProxy
   * ChangeForReader
+  * ServerAttributes
 * Public API headers .h have been renamed to .hpp
 * Added create participant methods that use environment XML profile for participant configuration.
 * New TypeObjectRegistry class to register/query TypeObjects/TypeIdentifiers.
@@ -68,6 +69,13 @@ Forthcoming
 * New `DomainParticipantExtendedQos` that includes both `DomainId` and `DomainParticipantQos` (extends `DomainParticipantFactory` API).
 * Make Blackbox tests not include any private API.
 * Remove all the private API include from Blackbox tests.
+* Discovery Server refactor:
+  * Clients and Servers no longer need a known GUID to connect between them.
+  * Servers are now configured specifying a LocatorList, instead of a RemoteServerAttributes list.
+  * Servers connect through a mesh topology. For a new server to join the topology, it must be connected to any server in it.
+  * Servers only redirect discovery information of their direct clients.
+  * Remote Discovery servers connection list can now be updated and modified at runtime without restrictions.
+  * Fast DDS CLI has been updated to allow the creation of servers without GUID.
 
 Version 2.14.0
 --------------