diff --git a/components/esp_netif/include/esp_netif.h b/components/esp_netif/include/esp_netif.h
index 199e4550fd..241be53da1 100644
--- a/components/esp_netif/include/esp_netif.h
+++ b/components/esp_netif/include/esp_netif.h
@@ -350,6 +350,18 @@ void esp_netif_action_add_ip6_address(void *esp_netif, esp_event_base_t base, in
  */
 void esp_netif_action_remove_ip6_address(void *esp_netif, esp_event_base_t base, int32_t event_id, void *data);
 
+/**
+ * @brief Manual configuration of the default netif
+ *
+ * This API overrides the automatic configuration of the default interface based on the route_prio
+ * If the selected netif is set default using this API, no other interface could be set-default disregarding
+ * its route_prio number (unless the selected netif gets destroyed)
+ *
+ * @param[in] esp_netif Handle to esp-netif instance
+ * @return ESP_OK on success
+ */
+esp_err_t esp_netif_set_default_netif(esp_netif_t *esp_netif);
+
 /**
  * @}
  */
diff --git a/components/esp_netif/lwip/esp_netif_lwip.c b/components/esp_netif/lwip/esp_netif_lwip.c
index 34b5973c29..392cd14949 100644
--- a/components/esp_netif/lwip/esp_netif_lwip.c
+++ b/components/esp_netif/lwip/esp_netif_lwip.c
@@ -92,6 +92,7 @@ typedef enum esp_netif_action {
     ESP_NETIF_UNDEF,
     ESP_NETIF_STARTED,
     ESP_NETIF_STOPPED,
+    ESP_NETIF_SET_DEFAULT,
 } esp_netif_action_t;
 
 //
@@ -103,6 +104,7 @@ static const char *TAG = "esp_netif_lwip";
 
 static bool tcpip_initialized = false;
 static esp_netif_t *s_last_default_esp_netif = NULL;
+static bool s_is_last_default_esp_netif_overridden = false;
 
 #if !LWIP_TCPIP_CORE_LOCKING
 static sys_sem_t api_sync_sem = NULL;
@@ -140,7 +142,7 @@ static inline esp_err_t esp_netif_lwip_ipc_call(esp_netif_api_fn fn, esp_netif_t
             .api_fn = fn
     };
 #if !LWIP_TCPIP_CORE_LOCKING
-    if (g_lwip_task != xTaskGetCurrentTaskHandle()) {
+    if (tcpip_initialized && g_lwip_task != xTaskGetCurrentTaskHandle()) {
         ESP_LOGD(TAG, "check: remote, if=%p fn=%p\n", netif, fn);
         sys_arch_sem_wait(&api_lock_sem, 0);
         tcpip_send_msg_wait_sem((tcpip_callback_fn)esp_netif_api_cb, &msg, &api_sync_sem);
@@ -176,7 +178,7 @@ static esp_netif_t* esp_netif_is_active(esp_netif_t *arg)
  *
  * @note: This function must be called from lwip thread
  */
-static void esp_netif_set_default_netif(esp_netif_t *esp_netif)
+static void esp_netif_set_default_netif_internal(esp_netif_t *esp_netif)
 {
     if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) {
 #if CONFIG_PPP_SUPPORT
@@ -199,17 +201,31 @@ static esp_err_t esp_netif_update_default_netif_lwip(esp_netif_api_msg_t *msg)
 
     ESP_LOGD(TAG, "%s %p", __func__, esp_netif);
 
+    if (s_is_last_default_esp_netif_overridden && action != ESP_NETIF_SET_DEFAULT) {
+        // check if manually configured default interface hasn't been destroyed
+        s_last_default_esp_netif = esp_netif_is_active(s_last_default_esp_netif);
+        if (s_last_default_esp_netif != NULL) {
+            return ESP_OK; // still valid -> don't update default netif
+        }
+        // invalid -> reset the manual override and perform auto update
+        s_is_last_default_esp_netif_overridden = false;
+    }
     switch (action) {
+        case ESP_NETIF_SET_DEFAULT:
+            s_last_default_esp_netif = esp_netif;
+            s_is_last_default_esp_netif_overridden = true;
+            esp_netif_set_default_netif_internal(s_last_default_esp_netif);
+        break;
         case ESP_NETIF_STARTED:
         {
             // check if previously default interface hasn't been destroyed in the meantime
             s_last_default_esp_netif = esp_netif_is_active(s_last_default_esp_netif);
             if (s_last_default_esp_netif && esp_netif_is_netif_up(s_last_default_esp_netif)
                 && (s_last_default_esp_netif->route_prio > esp_netif->route_prio)) {
-                esp_netif_set_default_netif(s_last_default_esp_netif);
+                esp_netif_set_default_netif_internal(s_last_default_esp_netif);
             } else if (esp_netif_is_netif_up(esp_netif)) {
                 s_last_default_esp_netif = esp_netif;
-                esp_netif_set_default_netif(s_last_default_esp_netif);
+                esp_netif_set_default_netif_internal(s_last_default_esp_netif);
             }
         }
         break;
@@ -235,7 +251,7 @@ static esp_err_t esp_netif_update_default_netif_lwip(esp_netif_api_msg_t *msg)
             }
             esp_netif_list_unlock();
             if (s_last_default_esp_netif && esp_netif_is_netif_up(s_last_default_esp_netif)) {
-                esp_netif_set_default_netif(s_last_default_esp_netif);
+                esp_netif_set_default_netif_internal(s_last_default_esp_netif);
             }
         }
         break;
@@ -254,6 +270,11 @@ static esp_err_t esp_netif_update_default_netif(esp_netif_t *esp_netif, esp_neti
     return esp_netif_lwip_ipc_call(esp_netif_update_default_netif_lwip, esp_netif, (void*)action);
 }
 
+esp_err_t esp_netif_set_default_netif(esp_netif_t *esp_netif)
+{
+    return esp_netif_update_default_netif(esp_netif, ESP_NETIF_SET_DEFAULT);
+}
+
 void esp_netif_set_ip4_addr(esp_ip4_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
 {
     ip4_addr_t *address = (ip4_addr_t*)addr;
@@ -605,10 +626,7 @@ void esp_netif_destroy(esp_netif_t *esp_netif)
 #if CONFIG_ESP_NETIF_L2_TAP
         vSemaphoreDelete(esp_netif->transmit_mutex);
 #endif // CONFIG_ESP_NETIF_L2_TAP
-        if (s_last_default_esp_netif == esp_netif) {
-            // clear last default netif if it happens to be this just destroyed interface
-            s_last_default_esp_netif = NULL;
-        }
+        esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED);
         free(esp_netif);
     }
 }
diff --git a/components/esp_netif/test/test_esp_netif.c b/components/esp_netif/test/test_esp_netif.c
index 1c2aa80a9f..212537dc97 100644
--- a/components/esp_netif/test/test_esp_netif.c
+++ b/components/esp_netif/test/test_esp_netif.c
@@ -1,10 +1,12 @@
+#include <string.h>
 #include "unity.h"
 #include "test_utils.h"
 #include "esp_netif.h"
 #include "esp_wifi.h"
 #include "nvs_flash.h"
 #include "esp_wifi_netif.h"
-#include <string.h>
+#include "lwip/netif.h"
+#include "esp_netif_net_stack.h"
 
 
 TEST_CASE("esp_netif: init and destroy", "[esp_netif]")
@@ -353,3 +355,61 @@ TEST_CASE("esp_netif: create and destroy default wifi interfaces", "[esp_netif][
     TEST_ASSERT_NOT_NULL(sta);
     esp_netif_destroy_default_wifi(sta);
 }
+
+static esp_err_t dummy_transmit(void* hd, void *buf, size_t length)
+{
+    return ESP_OK;
+}
+
+TEST_CASE("esp_netif: test routing priority", "[esp_netif]")
+{
+    test_case_uses_tcpip();
+    // interface key has to be a unique identifier
+    const char *if_keys[] = {"if0", "if1", "if2", "if3", "if4", "if5", "if6", "if7", "if8", "if9"};
+    const int nr_of_netifs = sizeof(if_keys) / sizeof(char *);
+    esp_netif_t *netifs[nr_of_netifs];
+    esp_netif_driver_ifconfig_t driver_config = { .handle =  (void*)1, .transmit = dummy_transmit };
+    // create 10 netifs with different route prio
+    int max_prio_i = nr_of_netifs / 2;  // index of netif with maximum route-prio
+    for (int i = 0; i < nr_of_netifs; ++i) {
+        esp_netif_inherent_config_t base_netif_config = { .if_key = if_keys[i],
+                                                          .route_prio = i > max_prio_i ? 0 : i };
+        esp_netif_config_t cfg = {  .base = &base_netif_config,
+                                    .stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_STA,
+                                    .driver = &driver_config };
+        netifs[i] = esp_netif_new(&cfg);
+        TEST_ASSERT_NOT_NULL(netifs[i]);
+        // set the interface up and connected -- to enable the default netif based on route_prio
+        esp_netif_action_start(netifs[i], 0, 0, 0);
+        esp_netif_action_connected(netifs[i], 0, 0, 0);
+    }
+    // route_prio increases with index until max_prio_i -> check this is the default netif
+    TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i]), netif_default);
+    // now we stop the max_prio netif and check the default is on the previous index (max_prio-1)
+    esp_netif_action_stop(netifs[max_prio_i], 0, 0, 0);
+    TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i - 1]), netif_default);
+
+    // now we override the default netif with API (which has route_prio == 0)
+    int override_prio_i = nr_of_netifs - 1;  // last netif to be set-default manually
+    esp_netif_set_default_netif(netifs[override_prio_i]);
+    // check the configured netif is default
+    TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[override_prio_i]), netif_default);
+    // try to start/connect the previously stopped netif with max_prio
+    esp_netif_action_start(netifs[max_prio_i], 0, 0, 0);
+    esp_netif_action_connected(netifs[max_prio_i], 0, 0, 0);
+    // and check the configured netif is still the default
+    TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[override_prio_i]), netif_default);
+    // we destroy the configured default netif
+    esp_netif_destroy(netifs[override_prio_i]);
+    // ...and check the max-prio netif is default now
+    TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i]), netif_default);
+    // stop the max_prio netif, to see the auto-default still works
+    esp_netif_action_stop(netifs[max_prio_i], 0, 0, 0);
+    // ...so the current default is on (max_prio-1)
+    TEST_ASSERT_EQUAL_PTR(esp_netif_get_netif_impl(netifs[max_prio_i - 1]), netif_default);
+    // destroy one by one and check it's been removed
+    for (int i=0; i < override_prio_i; ++i) {
+        esp_netif_destroy(netifs[i]);
+        TEST_ASSERT_FALSE(esp_netif_is_netif_listed(netifs[i]));
+    }
+}