diff --git a/config/esp32/components/chip/Kconfig b/config/esp32/components/chip/Kconfig
index 5c95ac50f91e23..57231e8d11375a 100644
--- a/config/esp32/components/chip/Kconfig
+++ b/config/esp32/components/chip/Kconfig
@@ -511,7 +511,7 @@ menu "CHIP Device Layer"
 
         config BLE_FAST_ADVERTISING_INTERVAL
             int "Fast Advertising Interval"
-            default 800
+            default 320
             depends on ENABLE_CHIPOBLE
             help
                 The interval (in units of 0.625ms) at which the device will send BLE advertisements while
diff --git a/examples/chip-tool/main.cpp b/examples/chip-tool/main.cpp
index af1ad826cb16c3..f30f5388cbbe1e 100644
--- a/examples/chip-tool/main.cpp
+++ b/examples/chip-tool/main.cpp
@@ -192,13 +192,14 @@ struct CommandArgs
 {
     IPAddress hostAddr;
     uint16_t port;
-    char * name;
+    uint16_t discriminator;
     uint8_t endpointId;
 };
 
 bool DetermineArgsBle(char * argv[], CommandArgs * commandArgs)
 {
-    commandArgs->name = argv[2];
+    std::string discriminator_str(argv[2]);
+    commandArgs->discriminator = std::stoi(discriminator_str);
     return true;
 }
 
@@ -289,9 +290,11 @@ void DoEcho(DeviceController::ChipDeviceController * controller, const char * id
     }
 }
 
-void DoEchoBle(DeviceController::ChipDeviceController * controller, const std::string & name)
+void DoEchoBle(DeviceController::ChipDeviceController * controller, const uint16_t discriminator)
 {
-    DoEcho(controller, name.c_str());
+    char name[4];
+    snprintf(name, sizeof(name), "%u", discriminator);
+    DoEcho(controller, "");
 }
 
 void DoEchoIP(DeviceController::ChipDeviceController * controller, const IPAddress & hostAddr, uint16_t port)
@@ -350,9 +353,9 @@ CHIP_ERROR ExecuteCommand(DeviceController::ChipDeviceController * controller, C
     switch (command)
     {
     case Command::EchoBle:
-        err = controller->ConnectDevice(kRemoteDeviceId, commandArgs.name, NULL, OnConnect, OnMessage, OnError);
+        err = controller->ConnectDevice(kRemoteDeviceId, commandArgs.discriminator, NULL, OnConnect, OnMessage, OnError);
         VerifyOrExit(err == CHIP_NO_ERROR, fprintf(stderr, "Failed to connect to the device"));
-        DoEchoBle(controller, commandArgs.name);
+        DoEchoBle(controller, commandArgs.discriminator);
         break;
 
     case Command::Echo:
diff --git a/src/ble/BleConnectionDelegate.h b/src/ble/BleConnectionDelegate.h
index bef2931339ac21..eb5a88beb4ff58 100644
--- a/src/ble/BleConnectionDelegate.h
+++ b/src/ble/BleConnectionDelegate.h
@@ -50,8 +50,8 @@ class DLL_EXPORT BleConnectionDelegate
     OnConnectionErrorFunct OnConnectionError;
 
     // Call this function to delegate the connection steps required to get a BLE_CONNECTION_OBJECT
-    // out of a peripheral name.
-    virtual void NewConnection(BleLayer * bleLayer, void * appState, const char * connName) = 0;
+    // out of a peripheral discriminator.
+    virtual void NewConnection(BleLayer * bleLayer, void * appState, const uint16_t connDiscriminator) = 0;
 };
 
 } /* namespace Ble */
diff --git a/src/ble/BleLayer.cpp b/src/ble/BleLayer.cpp
index fa2273623cb9ce..bbc1853e4add8c 100644
--- a/src/ble/BleLayer.cpp
+++ b/src/ble/BleLayer.cpp
@@ -369,19 +369,19 @@ BLE_ERROR BleLayer::Shutdown()
     return BLE_NO_ERROR;
 }
 
-BLE_ERROR BleLayer::NewBleConnection(void * appState, const char * connName,
+BLE_ERROR BleLayer::NewBleConnection(void * appState, const uint16_t connDiscriminator,
                                      BleConnectionDelegate::OnConnectionCompleteFunct onConnectionComplete,
                                      BleConnectionDelegate::OnConnectionErrorFunct onConnectionError)
 {
     BLE_ERROR err = BLE_NO_ERROR;
 
     VerifyOrExit(mState == kState_Initialized, err = BLE_ERROR_INCORRECT_STATE);
-    VerifyOrExit(connName != nullptr, err = BLE_ERROR_BAD_ARGS);
+    VerifyOrExit(connDiscriminator != 0, err = BLE_ERROR_BAD_ARGS);
     VerifyOrExit(mConnectionDelegate != nullptr, err = BLE_ERROR_INCORRECT_STATE);
 
     mConnectionDelegate->OnConnectionComplete = onConnectionComplete;
     mConnectionDelegate->OnConnectionError    = onConnectionError;
-    mConnectionDelegate->NewConnection(this, appState, connName);
+    mConnectionDelegate->NewConnection(this, appState, connDiscriminator);
 
 exit:
     return err;
diff --git a/src/ble/BleLayer.h b/src/ble/BleLayer.h
index 753683b21900fe..69520d71744155 100644
--- a/src/ble/BleLayer.h
+++ b/src/ble/BleLayer.h
@@ -253,7 +253,7 @@ class DLL_EXPORT BleLayer
                    BleApplicationDelegate * appDelegate, chip::System::Layer * systemLayer);
     BLE_ERROR Shutdown(void);
 
-    BLE_ERROR NewBleConnection(void * appState, const char * connName,
+    BLE_ERROR NewBleConnection(void * appState, const uint16_t connDiscriminator,
                                BleConnectionDelegate::OnConnectionCompleteFunct onConnectionComplete,
                                BleConnectionDelegate::OnConnectionErrorFunct onConnectionError);
     BLE_ERROR NewBleEndPoint(BLEEndPoint ** retEndPoint, BLE_CONNECTION_OBJECT connObj, BleRole role, bool autoClose);
diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp
index 9e1c004d78607c..b8da6be1fcdc21 100644
--- a/src/controller/CHIPDeviceController.cpp
+++ b/src/controller/CHIPDeviceController.cpp
@@ -145,7 +145,7 @@ CHIP_ERROR ChipDeviceController::Shutdown()
     return err;
 }
 
-CHIP_ERROR ChipDeviceController::ConnectDevice(NodeId remoteDeviceId, const char * deviceName, void * appReqState,
+CHIP_ERROR ChipDeviceController::ConnectDevice(NodeId remoteDeviceId, const uint16_t deviceDiscriminator, void * appReqState,
                                                NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived,
                                                ErrorHandler onError)
 {
@@ -161,8 +161,8 @@ CHIP_ERROR ChipDeviceController::ConnectDevice(NodeId remoteDeviceId, const char
     mOnNewConnection = onConnected;
 
     transport = new Transport::BLE();
-    err       = transport->Init(
-        Transport::BleConnectionParameters(this, DeviceLayer::ConnectivityMgr().GetBleLayer()).SetConnectionName(deviceName));
+    err       = transport->Init(Transport::BleConnectionParameters(this, DeviceLayer::ConnectivityMgr().GetBleLayer())
+                              .SetConnectionDiscriminator(deviceDiscriminator));
     SuccessOrExit(err);
     mUnsecuredTransport = transport->Retain();
 
diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h
index aa4d21c7144753..788f33877105ca 100644
--- a/src/controller/CHIPDeviceController.h
+++ b/src/controller/CHIPDeviceController.h
@@ -68,15 +68,15 @@ class DLL_EXPORT ChipDeviceController : public SecureSessionMgrCallback
      *   Connect to a CHIP device with a given name for Rendezvous
      *
      * @param[in] remoteDeviceId        The remote device Id.
-     * @param[in] deviceName            The name of the requested Device
+     * @param[in] deviceDiscriminator   The discriminator of the requested Device
      * @param[in] appReqState           Application specific context to be passed back when a message is received or on error
      * @param[in] onConnected           Callback for when the connection is established
      * @param[in] onMessageReceived     Callback for when a message is received
      * @param[in] onError               Callback for when an error occurs
      * @return CHIP_ERROR               The connection status
      */
-    CHIP_ERROR ConnectDevice(NodeId remoteDeviceId, const char * deviceName, void * appReqState, NewConnectionHandler onConnected,
-                             MessageReceiveHandler onMessageReceived, ErrorHandler onError);
+    CHIP_ERROR ConnectDevice(NodeId remoteDeviceId, const uint16_t deviceDiscriminator, void * appReqState,
+                             NewConnectionHandler onConnected, MessageReceiveHandler onMessageReceived, ErrorHandler onError);
 
     /**
      * @brief
diff --git a/src/darwin/CHIPTool/CHIPTool/QRCode/QRCodeViewController.m b/src/darwin/CHIPTool/CHIPTool/QRCode/QRCodeViewController.m
index 32d531f13aac98..b2b12b7536aaaf 100644
--- a/src/darwin/CHIPTool/CHIPTool/QRCode/QRCodeViewController.m
+++ b/src/darwin/CHIPTool/CHIPTool/QRCode/QRCodeViewController.m
@@ -340,22 +340,22 @@ - (void)handleRendezVous:(CHIPSetupPayload *)payload
         break;
     case kRendezvousInformationBLE:
         NSLog(@"Rendezvous BLE");
-        [self handleRendezVousBLE:[self getNetworkName:payload.discriminator]];
+        [self handleRendezVousBLE:payload.discriminator.unsignedShortValue];
         break;
     }
 }
 
 - (NSString *)getNetworkName:(NSNumber *)discriminator
 {
-    NSString * peripheralDiscriminator = [NSString stringWithFormat:@"%hX", discriminator.unsignedShortValue];
+    NSString * peripheralDiscriminator = [NSString stringWithFormat:@"%04u", discriminator.unsignedShortValue];
     NSString * peripheralFullName = [NSString stringWithFormat:@"%@%@", NETWORK_CHIP_PREFIX, peripheralDiscriminator];
     return peripheralFullName;
 }
 
-- (void)handleRendezVousBLE:(NSString *)name
+- (void)handleRendezVousBLE:(uint16_t)discriminator
 {
     NSError * error;
-    [self.chipController connect:name error:&error];
+    [self.chipController connect:discriminator error:&error];
 }
 
 - (void)handleRendezVousWiFi:(NSString *)name
diff --git a/src/darwin/Framework/CHIP/CHIPDeviceController.h b/src/darwin/Framework/CHIP/CHIPDeviceController.h
index 8022184cb6fa2a..1c864ab4e742cf 100644
--- a/src/darwin/Framework/CHIP/CHIPDeviceController.h
+++ b/src/darwin/Framework/CHIP/CHIPDeviceController.h
@@ -40,7 +40,7 @@ typedef void (^ControllerOnErrorBlock)(NSError * error);
       local_key:(NSData *)local_key
        peer_key:(NSData *)peer_key
           error:(NSError * __autoreleasing *)error;
-- (BOOL)connect:(NSString *)deviceName error:(NSError * __autoreleasing *)error;
+- (BOOL)connect:(uint16_t)deviceDiscriminator error:(NSError * __autoreleasing *)error;
 - (nullable AddressInfo *)getAddressInfo;
 - (BOOL)sendMessage:(NSData *)message error:(NSError * __autoreleasing *)error;
 - (BOOL)sendOnCommand;
diff --git a/src/darwin/Framework/CHIP/CHIPDeviceController.mm b/src/darwin/Framework/CHIP/CHIPDeviceController.mm
index 307c8d19e145c3..400ff1531a3794 100644
--- a/src/darwin/Framework/CHIP/CHIPDeviceController.mm
+++ b/src/darwin/Framework/CHIP/CHIPDeviceController.mm
@@ -229,13 +229,13 @@ - (BOOL)connect:(NSString *)ipAddress
     return YES;
 }
 
-- (BOOL)connect:(NSString *)deviceName error:(NSError * __autoreleasing *)error
+- (BOOL)connect:(uint16_t)deviceDiscriminator error:(NSError * __autoreleasing *)error
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
     [self.lock lock];
     err = self.cppController->ConnectDevice(
-        kRemoteDeviceId, [deviceName UTF8String], (__bridge void *) self, onConnected, onMessageReceived, onInternalError);
+        kRemoteDeviceId, deviceDiscriminator, (__bridge void *) self, onConnected, onMessageReceived, onInternalError);
     [self.lock unlock];
 
     if (err != CHIP_NO_ERROR) {
diff --git a/src/platform/Darwin/BleConnectionDelegate.h b/src/platform/Darwin/BleConnectionDelegate.h
index e1e9ae7f284dbb..da8d365c2152f2 100644
--- a/src/platform/Darwin/BleConnectionDelegate.h
+++ b/src/platform/Darwin/BleConnectionDelegate.h
@@ -29,7 +29,7 @@ namespace Internal {
 class BleConnectionDelegateImpl : public BleConnectionDelegate
 {
 public:
-    virtual void NewConnection(Ble::BleLayer * bleLayer, void * appState, const char * connName);
+    virtual void NewConnection(Ble::BleLayer * bleLayer, void * appState, const uint16_t connDiscriminator);
 };
 
 } // namespace Internal
diff --git a/src/platform/Darwin/BleConnectionDelegateImpl.mm b/src/platform/Darwin/BleConnectionDelegateImpl.mm
index 238a188d46adee..73fdc1f181cf57 100644
--- a/src/platform/Darwin/BleConnectionDelegateImpl.mm
+++ b/src/platform/Darwin/BleConnectionDelegateImpl.mm
@@ -34,14 +34,14 @@ @interface BleConnection : NSObject <CBCentralManagerDelegate, CBPeripheralDeleg
 
 @property (strong, nonatomic) dispatch_queue_t workQueue;
 @property (strong, nonatomic) CBCentralManager * centralManager;
-@property (strong, nonatomic) NSString * deviceName;
 @property (strong, nonatomic) CBPeripheral * peripheral;
+@property (unsafe_unretained, nonatomic) uint16_t deviceDiscriminator;
 @property (unsafe_unretained, nonatomic) void * appState;
 @property (unsafe_unretained, nonatomic) BleConnectionDelegate::OnConnectionCompleteFunct onConnectionComplete;
 @property (unsafe_unretained, nonatomic) BleConnectionDelegate::OnConnectionErrorFunct onConnectionError;
 @property (unsafe_unretained, nonatomic) chip::Ble::BleLayer * mBleLayer;
 
-- (id)initWithName:(NSString *)deviceName;
+- (id)initWithDiscriminator:(uint16_t)deviceDiscriminator;
 - (void)setBleLayer:(chip::Ble::BleLayer *)bleLayer;
 - (void)start;
 - (void)stop;
@@ -51,10 +51,10 @@ - (void)stop;
 namespace chip {
 namespace DeviceLayer {
     namespace Internal {
-        void BleConnectionDelegateImpl::NewConnection(Ble::BleLayer * bleLayer, void * appState, const char * connName)
+        void BleConnectionDelegateImpl::NewConnection(Ble::BleLayer * bleLayer, void * appState, const uint16_t deviceDiscriminator)
         {
             ChipLogProgress(Ble, "%s", __FUNCTION__);
-            BleConnection * ble = [[BleConnection alloc] initWithName:@(connName)];
+            BleConnection * ble = [[BleConnection alloc] initWithDiscriminator:deviceDiscriminator];
             [ble setBleLayer:bleLayer];
             ble.appState = appState;
             ble.onConnectionComplete = OnConnectionComplete;
@@ -69,11 +69,11 @@ @interface BleConnection ()
 
 @implementation BleConnection
 
-- (id)initWithName:(NSString *)deviceName
+- (id)initWithDiscriminator:(uint16_t)deviceDiscriminator
 {
     self = [super init];
     if (self) {
-        _deviceName = deviceName;
+        _deviceDiscriminator = deviceDiscriminator;
         _workQueue = dispatch_queue_create("com.chip.ble.work_queue", DISPATCH_QUEUE_SERIAL);
         _centralManager = [CBCentralManager alloc];
         [_centralManager initWithDelegate:self queue:_workQueue];
@@ -115,12 +115,30 @@ - (void)centralManager:(CBCentralManager *)central
         advertisementData:(NSDictionary *)advertisementData
                      RSSI:(NSNumber *)RSSI
 {
-    BOOL isConnectable = !![advertisementData objectForKey:CBAdvertisementDataIsConnectable];
-    NSString * localNameKey = [advertisementData objectForKey:CBAdvertisementDataLocalNameKey];
-    if (isConnectable && [localNameKey isEqual:_deviceName]) {
-        ChipLogProgress(Ble, "Connecting to device: %@", _deviceName);
-        [self connect:peripheral];
-        [self stopScanning];
+    NSNumber * isConnectable = [advertisementData objectForKey:CBAdvertisementDataIsConnectable];
+    if ([isConnectable boolValue]) {
+        CBUUID * shortChipServiceUUID = [BleConnection getShortestServiceUUID:&chip::Ble::CHIP_BLE_SVC_ID];
+
+        NSDictionary * servicesData = [advertisementData objectForKey:CBAdvertisementDataServiceDataKey];
+        for (CBUUID * serviceUUID in servicesData) {
+            if ([serviceUUID.data isEqualToData:shortChipServiceUUID.data]) {
+                NSData * serviceData = [servicesData objectForKey:serviceUUID];
+
+                int length = [serviceData length];
+                if (length == 3) {
+                    const uint8_t * bytes = (const uint8_t *) [serviceData bytes];
+                    uint8_t opCode = bytes[0];
+                    uint16_t discriminator = ((bytes[1] & 0x0F) << 8) | bytes[2];
+                    if (opCode == 0 && discriminator == _deviceDiscriminator) {
+                        ChipLogProgress(Ble, "Connecting to device: %@", peripheral);
+                        [self connect:peripheral];
+                        [self stopScanning];
+                    }
+                }
+
+                break;
+            }
+        }
     }
 }
 
@@ -343,6 +361,27 @@ + (void)fillServiceWithCharacteristicUuids:(CBCharacteristic *)characteristic
     memcpy(svcId->bytes, serviceFullUUID, sizeof(svcId->bytes));
 }
 
++ (CBUUID *)getShortestServiceUUID:(const chip::Ble::ChipBleUUID *)svcId
+{
+    // shorten the 16-byte UUID reported by BLE Layer to shortest possible, 2 or 4 bytes
+    // this is the BLE Service UUID Base. If a 16-byte service UUID partially matches with this 12 bytes,
+    // it could be shorten to 2 or 4 bytes.
+    static const uint8_t bleBaseUUID[12] = { 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
+    if (0 == memcmp(svcId->bytes + 4, bleBaseUUID, sizeof(bleBaseUUID))) {
+        // okay, let's try to shorten it
+        if ((0 == svcId->bytes[0]) && (0 == svcId->bytes[1])) {
+            // the highest 2 bytes are both 0, so we just need 2 bytes
+            return [CBUUID UUIDWithData:[NSData dataWithBytes:(svcId->bytes + 2) length:2]];
+        } else {
+            // we need to use 4 bytes
+            return [CBUUID UUIDWithData:[NSData dataWithBytes:svcId->bytes length:4]];
+        }
+    } else {
+        // it cannot be shorten as it doesn't match with the BLE Service UUID Base
+        return [CBUUID UUIDWithData:[NSData dataWithBytes:svcId->bytes length:16]];
+    }
+}
+
 - (void)setBleLayer:(chip::Ble::BleLayer *)bleLayer
 {
     _mBleLayer = bleLayer;
diff --git a/src/platform/ESP32/BLEManagerImpl.cpp b/src/platform/ESP32/BLEManagerImpl.cpp
index fd6659fa9cfdfd..189af476c85752 100644
--- a/src/platform/ESP32/BLEManagerImpl.cpp
+++ b/src/platform/ESP32/BLEManagerImpl.cpp
@@ -41,6 +41,13 @@
 
 #include <new>
 
+#define MAX_ADV_DATA_LEN 31
+#define CHIP_ADV_DATA_TYPE_FLAGS 0x01
+#define CHIP_ADV_DATA_FLAGS 0x06
+#define CHIP_ADV_DATA_TYPE_SERVICE_DATA 0x16
+#define CHIP_BLE_OPCODE 0x00
+#define CHIP_ADV_VERSION 0x00
+
 using namespace ::chip;
 using namespace ::chip::Ble;
 
@@ -617,8 +624,9 @@ CHIP_ERROR BLEManagerImpl::InitESPBleLayer(void)
 CHIP_ERROR BLEManagerImpl::ConfigureAdvertisingData(void)
 {
     CHIP_ERROR err;
-    esp_ble_adv_data_t advertData;
-    ESP32ChipServiceData chipServiceData;
+    uint8_t advData[MAX_ADV_DATA_LEN];
+    uint16_t advDataVersionDiscriminator = 0;
+    uint8_t index                        = 0;
 
     // If a custom device name has not been specified, generate a CHIP-standard name based on the
     // bottom digits of the Chip device id.
@@ -627,7 +635,7 @@ CHIP_ERROR BLEManagerImpl::ConfigureAdvertisingData(void)
     const uint16_t discriminator = 0x0F00;
     if (!GetFlag(mFlags, kFlag_UseCustomDeviceName))
     {
-        snprintf(mDeviceName, sizeof(mDeviceName), "%s%03" PRIX16, CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, discriminator);
+        snprintf(mDeviceName, sizeof(mDeviceName), "%s%04u", CHIP_DEVICE_CONFIG_BLE_DEVICE_NAME_PREFIX, discriminator);
         mDeviceName[kMaxDeviceNameLength] = 0;
     }
 
@@ -639,53 +647,25 @@ CHIP_ERROR BLEManagerImpl::ConfigureAdvertisingData(void)
         ExitNow();
     }
 
-    // Configure the contents of the advertising packet.
-    memset(&advertData, 0, sizeof(advertData));
-    advertData.set_scan_rsp        = false;
-    advertData.include_name        = true;
-    advertData.include_txpower     = false;
-    advertData.min_interval        = 0;
-    advertData.max_interval        = 0;
-    advertData.appearance          = 0;
-    advertData.manufacturer_len    = 0;
-    advertData.p_manufacturer_data = NULL;
-    advertData.service_data_len    = 0;
-    advertData.p_service_data      = NULL;
-    advertData.service_uuid_len    = sizeof(UUID_CHIPoBLEService);
-    advertData.p_service_uuid      = (uint8_t *) UUID_CHIPoBLEService;
-    advertData.flag                = ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT;
-    err                            = esp_ble_gap_config_adv_data(&advertData);
-    if (err != CHIP_NO_ERROR)
-    {
-        ChipLogError(DeviceLayer, "esp_ble_gap_config_adv_data(<advertising data>) failed: %s", ErrorStr(err));
-        ExitNow();
-    }
-
-    // Construct the Chip BLE Service Data to be sent in the scan response packet.  On the ESP32,
-    // the buffer given to esp_ble_gap_config_adv_data() must begin with the Chip BLE service UUID.
-    memcpy(chipServiceData.ServiceUUID, ShortUUID_CHIPoBLEService, sizeof(chipServiceData.ServiceUUID));
-    err = ConfigurationMgr().GetBLEDeviceIdentificationInfo(chipServiceData.DeviceIdInfo);
-    SuccessOrExit(err);
-
-    // Configure the contents of the scan response packet.
-    memset(&advertData, 0, sizeof(advertData));
-    advertData.set_scan_rsp        = true;
-    advertData.include_name        = false;
-    advertData.include_txpower     = true;
-    advertData.min_interval        = 0;
-    advertData.max_interval        = 0;
-    advertData.appearance          = 0;
-    advertData.manufacturer_len    = 0;
-    advertData.p_manufacturer_data = NULL;
-    advertData.service_data_len    = sizeof(chipServiceData);
-    advertData.p_service_data      = (uint8_t *) &chipServiceData;
-    advertData.service_uuid_len    = 0;
-    advertData.p_service_uuid      = NULL;
-    advertData.flag                = 0;
-    err                            = esp_ble_gap_config_adv_data(&advertData);
+    advDataVersionDiscriminator = (discriminator | (CHIP_ADV_VERSION << 12));
+
+    memset(advData, 0, sizeof(advData));
+    advData[index++] = 0x02;                             // length
+    advData[index++] = CHIP_ADV_DATA_TYPE_FLAGS;         // AD type : flags
+    advData[index++] = CHIP_ADV_DATA_FLAGS;              // AD value
+    advData[index++] = 0x06;                             // length
+    advData[index++] = CHIP_ADV_DATA_TYPE_SERVICE_DATA;  // AD type: (Service Data - 16-bit UUID)
+    advData[index++] = ShortUUID_CHIPoBLEService[0];     // AD value
+    advData[index++] = ShortUUID_CHIPoBLEService[1];     // AD value
+    advData[index++] = CHIP_BLE_OPCODE;                  // Used to differentiate from operational CHIP Ble adv
+    advData[index++] = advDataVersionDiscriminator >> 8; // Bits[15:12] == version - Bits[11:0] Discriminator
+    advData[index++] = advDataVersionDiscriminator & 0x00FF;
+
+    // Construct the Chip BLE Service Data to be sent in the scan response packet.
+    err = esp_ble_gap_config_adv_data_raw(advData, sizeof(advData));
     if (err != CHIP_NO_ERROR)
     {
-        ChipLogError(DeviceLayer, "esp_ble_gap_config_adv_data(<scan response>) failed: %s", ErrorStr(err));
+        ChipLogError(DeviceLayer, "esp_ble_gap_config_adv_data_raw(<raw_data>) failed: %s", ErrorStr(err));
         ExitNow();
     }
 
@@ -1215,7 +1195,7 @@ void BLEManagerImpl::HandleGAPEvent(esp_gap_ble_cb_event_t event, esp_ble_gap_cb
 
     switch (event)
     {
-    case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
+    case ESP_GAP_BLE_ADV_DATA_RAW_SET_COMPLETE_EVT:
 
         if (param->adv_data_cmpl.status != ESP_BT_STATUS_SUCCESS)
         {
diff --git a/src/platform/ESP32/ConnectivityManagerImpl.cpp b/src/platform/ESP32/ConnectivityManagerImpl.cpp
index 79c6e5d4aa6e59..c583e9b061ff0e 100644
--- a/src/platform/ESP32/ConnectivityManagerImpl.cpp
+++ b/src/platform/ESP32/ConnectivityManagerImpl.cpp
@@ -911,7 +911,7 @@ CHIP_ERROR ConnectivityManagerImpl::ConfigureWiFiAP()
     // TODO Pull this from the configuration manager
     const uint16_t discriminator = 0x0F00;
 
-    snprintf((char *) wifiConfig.ap.ssid, sizeof(wifiConfig.ap.ssid), "%s%03" PRIX16, CHIP_DEVICE_CONFIG_WIFI_AP_SSID_PREFIX,
+    snprintf((char *) wifiConfig.ap.ssid, sizeof(wifiConfig.ap.ssid), "%s%04u", CHIP_DEVICE_CONFIG_WIFI_AP_SSID_PREFIX,
              discriminator);
     wifiConfig.ap.channel         = CHIP_DEVICE_CONFIG_WIFI_AP_CHANNEL;
     wifiConfig.ap.authmode        = WIFI_AUTH_OPEN;
diff --git a/src/transport/BLE.cpp b/src/transport/BLE.cpp
index b8bc5f4273075c..b3cf766a04b061 100644
--- a/src/transport/BLE.cpp
+++ b/src/transport/BLE.cpp
@@ -54,7 +54,7 @@ CHIP_ERROR BLE::Init(BleConnectionParameters & params)
     CHIP_ERROR err = CHIP_NO_ERROR;
 
     VerifyOrExit(mState == State::kNotReady, err = CHIP_ERROR_INCORRECT_STATE);
-    VerifyOrExit(params.HasConnectionObject() || params.HasConnectionName(), err = CHIP_ERROR_INVALID_ARGUMENT);
+    VerifyOrExit(params.HasConnectionObject() || params.HasConnectionDiscriminator(), err = CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(params.GetDeviceController(), err = CHIP_ERROR_INVALID_ARGUMENT);
     VerifyOrExit(params.GetBleLayer(), err = CHIP_ERROR_INVALID_ARGUMENT);
 
@@ -64,7 +64,7 @@ CHIP_ERROR BLE::Init(BleConnectionParameters & params)
     }
     else
     {
-        err = InitInternal(params.GetBleLayer(), params.GetConnectionName());
+        err = DelegateConnection(params.GetBleLayer(), params.GetConnectionDiscriminator());
     }
     SuccessOrExit(err);
 
@@ -107,11 +107,12 @@ CHIP_ERROR BLE::InitInternal(Ble::BleLayer * bleLayer, BLE_CONNECTION_OBJECT con
     return err;
 }
 
-CHIP_ERROR BLE::InitInternal(Ble::BleLayer * bleLayer, const char * connName)
+CHIP_ERROR BLE::DelegateConnection(Ble::BleLayer * bleLayer, const uint16_t connDiscriminator)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    err = bleLayer->NewBleConnection(reinterpret_cast<void *>(this), connName, OnBleConnectionComplete, OnBleConnectionError);
+    err = bleLayer->NewBleConnection(reinterpret_cast<void *>(this), connDiscriminator, OnBleConnectionComplete,
+                                     OnBleConnectionError);
     SuccessOrExit(err);
 
 exit:
diff --git a/src/transport/BLE.h b/src/transport/BLE.h
index cefbe7c2ff4feb..69472f0b3fbdb0 100644
--- a/src/transport/BLE.h
+++ b/src/transport/BLE.h
@@ -74,11 +74,11 @@ class BleConnectionParameters
         return *this;
     }
 
-    bool HasConnectionName() const { return mConnectionName != nullptr; };
-    const char * GetConnectionName() const { return mConnectionName; };
-    BleConnectionParameters & SetConnectionName(const char * connName)
+    bool HasConnectionDiscriminator() const { return mConnectionDiscriminator != 0; };
+    uint16_t GetConnectionDiscriminator() const { return mConnectionDiscriminator; };
+    BleConnectionParameters & SetConnectionDiscriminator(const uint16_t connDiscriminator)
     {
-        mConnectionName = connName;
+        mConnectionDiscriminator = connDiscriminator;
 
         return *this;
     }
@@ -87,7 +87,7 @@ class BleConnectionParameters
     DeviceController::ChipDeviceController * mDeviceController = nullptr; ///< Associated device controller
     Ble::BleLayer * mLayer                                     = nullptr; ///< Associated ble layer
     BLE_CONNECTION_OBJECT mConnectionObj                       = 0;       ///< the target peripheral BLE_CONNECTION_OBJECT
-    const char * mConnectionName                               = nullptr; ///< the target peripheral name
+    uint16_t mConnectionDiscriminator                          = 0;       ///< the target peripheral discriminator
 };
 
 /** Implements a transport using BLE. */
@@ -123,7 +123,7 @@ class DLL_EXPORT BLE : public Base
 
 private:
     CHIP_ERROR InitInternal(Ble::BleLayer * bleLayer, BLE_CONNECTION_OBJECT connObj);
-    CHIP_ERROR InitInternal(Ble::BleLayer * bleLayer, const char * connName);
+    CHIP_ERROR DelegateConnection(Ble::BleLayer * bleLayer, const uint16_t connDiscriminator);
 
     // Those functions are BLEConnectionDelegate callbacks used when the connection
     // parameters used a name instead of a BLE_CONNECTION_OBJECT.