diff --git a/src/plugins/intel_npu/src/plugin/include/plugin.hpp b/src/plugins/intel_npu/src/plugin/include/plugin.hpp
index d759a27083e2..61b5a6cf08d6 100644
--- a/src/plugins/intel_npu/src/plugin/include/plugin.hpp
+++ b/src/plugins/intel_npu/src/plugin/include/plugin.hpp
@@ -6,6 +6,7 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 
 #include "backends_registry.hpp"
@@ -62,6 +63,21 @@ class Plugin : public ov::IPlugin {
                                     const ov::AnyMap& properties) const override;
 
 private:
+    // applies ov::log::level from per-call properties and restores the previous level on scope exit
+    // permanent level changes belong in set_property(); per-call properties are scoped to the call
+    class LogLevelScope {
+    public:
+        LogLevelScope(const ov::AnyMap& props, Logger& instanceLogger);
+        ~LogLevelScope();
+        LogLevelScope(const LogLevelScope&) = delete;
+        LogLevelScope& operator=(const LogLevelScope&) = delete;
+
+    private:
+        Logger& _instanceLogger;
+        std::optional<ov::log::Level> _prevGlobal;
+        std::optional<ov::log::Level> _prevInstance;
+    };
+
     void update_log_level(const ov::AnyMap& properties) const;
 
     /**
diff --git a/src/plugins/intel_npu/src/plugin/src/plugin.cpp b/src/plugins/intel_npu/src/plugin/src/plugin.cpp
index fcc4a43dd2fb..ef28f6b98084 100644
--- a/src/plugins/intel_npu/src/plugin/src/plugin.cpp
+++ b/src/plugins/intel_npu/src/plugin/src/plugin.cpp
@@ -6,6 +6,7 @@
 
 #include <fstream>
 #include <numeric>
+#include <optional>
 
 #include "compiled_model.hpp"
 #include "intel_npu/common/compiler_adapter_factory.hpp"
@@ -327,6 +328,14 @@ void init_config(const IEngineBackend* backend, OptionsDesc& options, FilteredCo
     }
 }
 
+std::optional<ov::log::Level> read_log_level(const ov::AnyMap& properties) {
+    const auto it = properties.find(ov::log::level.name());
+    if (it == properties.end()) {
+        return std::nullopt;
+    }
+    return it->second.as<ov::log::Level>();
+}
+
 }  // namespace
 
 namespace intel_npu {
@@ -389,7 +398,7 @@ bool Plugin::is_property_supported(const std::string& name, const ov::AnyMap& ar
 std::shared_ptr<ov::ICompiledModel> Plugin::compile_model(const std::shared_ptr<const ov::Model>& model,
                                                           const ov::AnyMap& properties) const {
     OV_ITT_SCOPED_TASK(itt::domains::NPUPlugin, "Plugin::compile_model");
-    update_log_level(properties);
+    LogLevelScope logScope(properties, _logger);
 
     // Before going any further: if
     // ... 1 - NPUW mode is activated
@@ -631,7 +640,7 @@ ov::SoPtr<ov::IRemoteContext> Plugin::get_default_context(const ov::AnyMap&) con
 
 std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& stream, const ov::AnyMap& properties) const {
     OV_ITT_SCOPED_TASK(itt::domains::NPUPlugin, "Plugin::import_model");
-    update_log_level(properties);
+    LogLevelScope logScope(properties, _logger);
 
     if (properties.find(ov::hint::compiled_blob.name()) != properties.end()) {
         _logger.warning("ov::hint::compiled_blob is no longer supported for import_model(stream) API! Please use new "
@@ -698,7 +707,7 @@ std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& stream,
 std::shared_ptr<ov::ICompiledModel> Plugin::import_model(const ov::Tensor& compiledBlob,
                                                          const ov::AnyMap& properties) const {
     OV_ITT_SCOPED_TASK(itt::domains::NPUPlugin, "Plugin::import_model");
-    update_log_level(properties);
+    LogLevelScope logScope(properties, _logger);
 
     // Need to create intermediate istream for NPUW
     ov::SharedStreamBuffer buffer{compiledBlob.data(), compiledBlob.get_byte_size()};
@@ -758,7 +767,7 @@ std::shared_ptr<ov::ICompiledModel> Plugin::import_model(const ov::Tensor& compi
 ov::SupportedOpsMap Plugin::query_model(const std::shared_ptr<const ov::Model>& model,
                                         const ov::AnyMap& properties) const {
     OV_ITT_SCOPED_TASK(itt::domains::NPUPlugin, "Plugin::query_model");
-    update_log_level(properties);
+    LogLevelScope logScope(properties, _logger);
 
     auto localProperties = properties;
 
@@ -975,11 +984,33 @@ std::shared_ptr<ov::ICompiledModel> Plugin::parse(const ov::Tensor& tensorBig,
     return std::make_shared<CompiledModel>(modelDummy, shared_from_this(), device, graph, localConfig, batchSize);
 }
 
+Plugin::LogLevelScope::LogLevelScope(const ov::AnyMap& props, Logger& instanceLogger)
+    : _instanceLogger(instanceLogger) {
+    const auto lvl = read_log_level(props);
+    if (!lvl) {
+        return;
+    }
+    _prevGlobal = Logger::global().level();
+    _prevInstance = _instanceLogger.level();
+    Logger::global().setLevel(*lvl);
+    _instanceLogger.setLevel(*lvl);
+}
+
+Plugin::LogLevelScope::~LogLevelScope() {
+    if (!_prevGlobal) {
+        return;
+    }
+    Logger::global().setLevel(*_prevGlobal);
+    _instanceLogger.setLevel(*_prevInstance);
+}
+
 void Plugin::update_log_level(const ov::AnyMap& properties) const {
-    if (properties.count(ov::log::level.name()) != 0) {
-        Logger::global().setLevel(properties.at(ov::log::level.name()).as<ov::log::Level>());
-        _logger.setLevel(properties.at(ov::log::level.name()).as<ov::log::Level>());
+    const auto lvl = read_log_level(properties);
+    if (!lvl) {
+        return;
     }
+    Logger::global().setLevel(*lvl);
+    _logger.setLevel(*lvl);
 }
 
 std::atomic<int> Plugin::_compiledModelLoadCounter{1};
diff --git a/src/plugins/intel_npu/tests/functional/behavior/compiled_model/compatibility_string.hpp b/src/plugins/intel_npu/tests/functional/behavior/compiled_model/compatibility_string.hpp
index bfa353c62a57..f87c84b7a99f 100644
--- a/src/plugins/intel_npu/tests/functional/behavior/compiled_model/compatibility_string.hpp
+++ b/src/plugins/intel_npu/tests/functional/behavior/compiled_model/compatibility_string.hpp
@@ -29,12 +29,21 @@ class ClassCompatibilityStringTestNPU : public OVCompiledModelPropertiesBase,
     std::string deviceName;
     ov::Core core;
 
+private:
+    std::optional<utils::LoggerLevelGuard> _logGuard;
+
 public:
     void SetUp() override {
+        _logGuard.emplace(::intel_npu::Logger::global().level());
         SKIP_IF_CURRENT_TEST_IS_DISABLED();
         OVCompiledModelPropertiesBase::SetUp();
         deviceName = GetParam();
     }
+
+    void TearDown() override {
+        _logGuard.reset();
+        OVCompiledModelPropertiesBase::TearDown();
+    }
     static std::string getTestCaseName(testing::TestParamInfo<std::string> obj) {
         auto targetDevice = obj.param;
         std::replace(targetDevice.begin(), targetDevice.end(), ':', '_');
@@ -114,11 +123,11 @@ TEST_P(ClassCompatibilityStringTestSuite, RuntimeRequirementsIsSupported) {
     ASSERT_FALSE(it->is_mutable());
     OV_ASSERT_NO_THROW(auto requirements = compiledModel.get_property(ov::runtime_requirements));
 
-    OV_ASSERT_NO_THROW(compiledModel = core.compile_model(
-                           model,
-                           deviceName,
-                           {ov::intel_npu::compiler_type(ov::intel_npu::CompilerType::DRIVER),
-                            ov::intel_npu::bypass_umd_caching(true)}));
+    OV_ASSERT_NO_THROW(compiledModel =
+                           core.compile_model(model,
+                                              deviceName,
+                                              {ov::intel_npu::compiler_type(ov::intel_npu::CompilerType::DRIVER),
+                                               ov::intel_npu::bypass_umd_caching(true)}));
     // Test that RUNTIME_REQUIREMENTS is supported for CID when the L0 graph extension version >= 1.16,
     // and unsupported for earlier driver versions. CIP always supports it.
     OV_ASSERT_NO_THROW(properties = compiledModel.get_property(ov::supported_properties));
@@ -155,11 +164,11 @@ TEST_P(ClassCompatibilityStringTestSuite, RuntimeRequirementsValueIsReadableWhen
     OV_ASSERT_NO_THROW(requirements = compiledModel.get_property(ov::runtime_requirements));
     ASSERT_FALSE(requirements.empty());
 
-    OV_ASSERT_NO_THROW(compiledModel = core.compile_model(
-                           model,
-                           deviceName,
-                           {ov::intel_npu::compiler_type(ov::intel_npu::CompilerType::DRIVER),
-                            ov::intel_npu::bypass_umd_caching(true)}));
+    OV_ASSERT_NO_THROW(compiledModel =
+                           core.compile_model(model,
+                                              deviceName,
+                                              {ov::intel_npu::compiler_type(ov::intel_npu::CompilerType::DRIVER),
+                                               ov::intel_npu::bypass_umd_caching(true)}));
 
     OV_ASSERT_NO_THROW(properties = compiledModel.get_property(ov::supported_properties));
     it = find(properties.cbegin(), properties.cend(), ov::runtime_requirements);
diff --git a/src/plugins/intel_npu/tests/functional/behavior/compiled_model/property.hpp b/src/plugins/intel_npu/tests/functional/behavior/compiled_model/property.hpp
index b57ed49069be..2fa00eb68a29 100644
--- a/src/plugins/intel_npu/tests/functional/behavior/compiled_model/property.hpp
+++ b/src/plugins/intel_npu/tests/functional/behavior/compiled_model/property.hpp
@@ -42,15 +42,26 @@ class ClassExecutableNetworkGetPropertiesTestNPU
     ov::Any configValue;
     ov::Core ie;
 
+private:
+    std::optional<ov::test::utils::LoggerLevelGuard> _logGuard;
+
 public:
     void SetUp() override {
+        _logGuard.emplace(::intel_npu::Logger::global().level());
         SKIP_IF_CURRENT_TEST_IS_DISABLED();
+
         OVCompiledModelPropertiesBase::SetUp();
+
         deviceName = std::get<0>(GetParam());
         std::tie(configKey, configValue) = std::get<1>(GetParam());
 
         model = ov::test::utils::make_conv_pool_relu();
     }
+
+    void TearDown() override {
+        _logGuard.reset();
+        OVCompiledModelPropertiesBase::TearDown();
+    }
     static std::string getTestCaseName(
         testing::TestParamInfo<std::tuple<std::string, std::pair<std::string, ov::Any>>> obj) {
         std::string targetDevice;
@@ -366,6 +377,7 @@ TEST_P(CheckCompilerTypeProperty, CheckLogAfterSettingExtraConfigToGetProperty)
     std::string logs;
     std::mutex logs_mutex;
     ov::Core core;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     // Keep this std::function alive while logging is active.
     std::function<void(std::string_view)> log_cb = [&](std::string_view msg) {
@@ -397,6 +409,7 @@ TEST_P(CheckCompilerTypeProperty, CheckLogAfterGettingPropertyWithExtraConfig) {
     std::string logs;
     std::mutex logs_mutex;
     ov::Core core;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     core.set_property(deviceName, ov::log::level(ov::log::Level::INFO));
 
@@ -433,6 +446,7 @@ TEST_P(CheckCompilerTypeProperty, SetRuntimeProperty) {
     std::string logs;
     std::mutex logs_mutex;
     ov::Core core;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     core.set_property(deviceName, ov::log::level(ov::log::Level::INFO));
 
@@ -466,6 +480,7 @@ TEST_P(CheckCompilerTypeProperty, SetCompilerPropertyForDifferentCompiler) {
     std::string logs;
     std::mutex logs_mutex;
     ov::Core core;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     core.set_property(deviceName, ov::log::level(ov::log::Level::INFO));
 
@@ -515,6 +530,7 @@ TEST_P(CheckCompilerTypeProperty, GetCompilerVersion) {
     std::string logs;
     std::mutex logs_mutex;
     ov::Core core;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     core.set_property(deviceName, ov::log::level(ov::log::Level::INFO));
 
@@ -615,6 +631,7 @@ TEST_P(CheckCompilerPropertyWhenImporting, ExpectedNoThrowFromImportWithCompiler
     ov::Core core_compile, core_import;
     ov::CompiledModel compiled_model;
     std::stringstream export_stream;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     OV_ASSERT_NO_THROW(compiled_model = core_compile.compile_model(model, deviceName));
     OV_ASSERT_NO_THROW(compiled_model.export_model(export_stream));
@@ -697,6 +714,7 @@ TEST_P(CheckCompilerPropertyWhenImporting, CheckImportWithCompilerProperty) {
     ov::Core core_for_importing;
     ov::CompiledModel compiled_model;
     std::stringstream export_stream;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     OV_ASSERT_NO_THROW(compiled_model = core_for_compiler.compile_model(model, deviceName));
     OV_ASSERT_NO_THROW(compiled_model.export_model(export_stream));
@@ -737,6 +755,7 @@ TEST_P(CheckCompilerPropertyWhenImporting, CheckImportWithCompilerPropertyAfterC
     ov::Core core;
     ov::CompiledModel compiled_model;
     std::stringstream export_stream;
+    ov::test::utils::LoggerLevelGuard levelGuard(::intel_npu::Logger::global().level());
 
     OV_ASSERT_NO_THROW(compiled_model = core.compile_model(model, deviceName));
     OV_ASSERT_NO_THROW(compiled_model.export_model(export_stream));
@@ -778,9 +797,8 @@ TEST_P(CheckCpuPinning, CheckCompileModelWithCpuPinningFromSetProperty) {
     ov::Core core;
     ov::CompiledModel compiled_model;
 
-    ov::log::Level previous_log_level = ov::log::Level::NO;
-    OV_ASSERT_NO_THROW(previous_log_level = core.get_property(deviceName, ov::log::level));
-    core.set_property(deviceName, ov::log::level(ov::log::Level::INFO));
+    ov::test::utils::LoggerLevelGuard logGuard(ov::log::Level::WARNING);
+    core.set_property(deviceName, ov::log::level(ov::log::Level::WARNING));
 
     // Keep this std::function alive while logging is active.
     std::function<void(std::string_view)> log_cb = [&](std::string_view msg) {
@@ -794,7 +812,6 @@ TEST_P(CheckCpuPinning, CheckCompileModelWithCpuPinningFromSetProperty) {
         OV_ASSERT_NO_THROW(core.set_property(deviceName, ov::hint::enable_cpu_pinning(true)));
         OV_ASSERT_NO_THROW(compiled_model = core.compile_model(model, deviceName));
     }
-    OV_ASSERT_NO_THROW(core.set_property(deviceName, ov::log::level(previous_log_level)));
 
     bool enable_cpu_pinning = false;
     OV_ASSERT_NO_THROW(enable_cpu_pinning = compiled_model.get_property(ov::hint::enable_cpu_pinning));
@@ -824,9 +841,7 @@ TEST_P(CheckCpuPinning, CheckCompileModelWithCpuPinningFromCompileProperty) {
     ov::Core core;
     ov::CompiledModel compiled_model;
 
-    ov::log::Level previous_log_level = ov::log::Level::NO;
-    OV_ASSERT_NO_THROW(previous_log_level = core.get_property(deviceName, ov::log::level));
-    core.set_property(deviceName, ov::log::level(ov::log::Level::INFO));
+    ov::test::utils::LoggerLevelGuard logGuard(ov::log::Level::WARNING);
 
     // Keep this std::function alive while logging is active.
     std::function<void(std::string_view)> log_cb = [&](std::string_view msg) {
@@ -837,10 +852,11 @@ TEST_P(CheckCpuPinning, CheckCompileModelWithCpuPinningFromCompileProperty) {
 
     {
         ov::test::utils::LogCallbackGuard log_callback_guard(log_cb);
-        OV_ASSERT_NO_THROW(compiled_model =
-                               core.compile_model(model, deviceName, {ov::hint::enable_cpu_pinning(true)}));
+        OV_ASSERT_NO_THROW(compiled_model = core.compile_model(
+                               model,
+                               deviceName,
+                               {ov::hint::enable_cpu_pinning(true), ov::log::level(ov::log::Level::WARNING)}));
     }
-    OV_ASSERT_NO_THROW(core.set_property(deviceName, ov::log::level(previous_log_level)));
 
     bool enable_cpu_pinning = false;
     OV_ASSERT_NO_THROW(enable_cpu_pinning = compiled_model.get_property(ov::hint::enable_cpu_pinning));
diff --git a/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_dynamic.cpp b/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_dynamic.cpp
index e1e1ebe35d79..5b678a1d96f5 100644
--- a/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_dynamic.cpp
+++ b/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_dynamic.cpp
@@ -1,4 +1,3 @@
-//
 // Copyright (C) 2018-2026 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
diff --git a/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_run.hpp b/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_run.hpp
index 652e691a4eaf..37a24271f642 100644
--- a/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_run.hpp
+++ b/src/plugins/intel_npu/tests/functional/behavior/ov_infer_request/infer_request_run.hpp
@@ -2305,11 +2305,10 @@ TEST_P(CpuVaTensorsTests, checkResultsAfterRawMemoryIsDestroyedAndReallocatedAft
         logs.push_back('\n');
     };
 
-    internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
     {
-        // don't flood console with messages from model compilation
         utils::LogCallbackGuard log_callback_guard(log_cb);
         ov::CompiledModel compiled_model = internal_core.compile_model(model, target_device, configuration);
+        internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
         inference_request = compiled_model.create_infer_request();
     }
     logs.clear();
@@ -2369,11 +2368,10 @@ TEST_P(CpuVaTensorsTests, checkResultsAfterRunningWithSameRawMemoryMultipleTimes
     float* input_data = static_cast<float*>(::operator new(shape_size * sizeof(float), std::align_val_t(4096)));
     float* output_data = static_cast<float*>(::operator new(shape_size * sizeof(float), std::align_val_t(4096)));
 
-    internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
     {
-        // don't flood console with messages from model compilation
         utils::LogCallbackGuard log_callback_guard(log_cb);
         ov::CompiledModel compiled_model = internal_core.compile_model(model, target_device, configuration);
+        internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
         inference_request = compiled_model.create_infer_request();
         inference_request.set_input_tensor(ov::Tensor{ov::element::f32, shape, input_data});
         inference_request.set_output_tensor(ov::Tensor{ov::element::f32, shape, output_data});
@@ -2435,11 +2433,10 @@ TEST_P(CpuVaTensorsTests, checkResultsAfterRunningWithSameZeroTensorMultipleTime
         logs.push_back('\n');
     };
 
-    internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
     {
-        // don't flood console with messages from model compilation
         utils::LogCallbackGuard log_callback_guard(log_cb);
         ov::CompiledModel compiled_model = internal_core.compile_model(model, target_device, configuration);
+        internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
         inference_request = compiled_model.create_infer_request();
         input_tensor = inference_request.get_input_tensor();
         output_tensor = inference_request.get_output_tensor();
@@ -2500,11 +2497,10 @@ TEST_P(CpuVaTensorsTests, checkResultsAfterRunningWithSameZeroHostTensorMultiple
     float* input_data = input_tensor.data<float>();
     float* output_data = output_tensor.data<float>();
 
-    internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
     {
-        // don't flood console with messages from model compilation
         utils::LogCallbackGuard log_callback_guard(log_cb);
         ov::CompiledModel compiled_model = internal_core.compile_model(model, target_device, configuration);
+        internal_core.set_property(target_device, ov::log::level(ov::log::Level::DEBUG));
         inference_request = compiled_model.create_infer_request();
         inference_request.set_input_tensor(input_tensor);
         inference_request.set_output_tensor(output_tensor);
@@ -2580,8 +2576,7 @@ TEST_P(CpuVaTensorsTests, checkResultsAfterRunningWithSameRawMemoryMultipleTimes
     ::operator delete(output_data, std::align_val_t(4096));
 }
 
-class DynamicBoundsTests : public InferRequestRunTests
-{
+class DynamicBoundsTests : public InferRequestRunTests {
 public:
     void SetUp() override {
         InferRequestRunTests::SetUp();
diff --git a/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.cpp b/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.cpp
index e22c5ac8c228..b2bebc3ce687 100644
--- a/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.cpp
+++ b/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.cpp
@@ -38,7 +38,7 @@ static std::string getTestCaseName(const testing::TestParamInfo<std::string>& ob
 }
 }  // namespace OVClassNetworkTestName
 
-const std::vector<ov::AnyMap> configs = {{}};
+const std::vector<ov::AnyMap> configs = {{ov::log::level(ov::log::Level::ERR)}};
 
 #ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
 INSTANTIATE_TEST_SUITE_P(compatibility_smoke_BehaviorTests_OVClassBasicTestP,
diff --git a/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.hpp b/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.hpp
index f490f9da0e26..e51ff296e585 100644
--- a/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.hpp
+++ b/src/plugins/intel_npu/tests/functional/behavior/ov_plugin/core_integration.hpp
@@ -66,10 +66,10 @@ class OVClassBaseTestPNPU : public OVClassNetworkTest,
     }
 
     void SetUp() override {
-        std::tie(target_device, configuration) = this->GetParam();
         SKIP_IF_CURRENT_TEST_IS_DISABLED();
+
         APIBaseTest::SetUp();
-        SKIP_IF_CURRENT_TEST_IS_DISABLED();
+        std::tie(target_device, configuration) = this->GetParam();
         // Generic network
         actualNetwork = ov::test::utils::make_split_conv_concat();
         // Quite simple network
@@ -383,7 +383,7 @@ TEST_P(OVClassGetMetricAndPrintNoThrow, NpuDeviceAllocMemSizeSameAfterDestroyInf
     ov::CompiledModel compiledModel;
     auto model = createModelWithLargeSize();
 
-    //Warm up inference to initialize driver scratch buffers
+    // Warm up inference to initialize driver scratch buffers
     OV_ASSERT_NO_THROW(compiledModel = core.compile_model(model, target_device));
     auto inferRequest = compiledModel.create_infer_request();
     inferRequest.infer();
@@ -452,6 +452,37 @@ TEST_P(OVClassCompileModel, CompileModelWithDifferentThreadNumbers) {
         testing::HasSubstr("ov::compilation_num_threads must be positive int32 value"));
 }
 
+TEST_P(OVClassNetworkTestPNPU, smoke_LogLevelPerCallPropertyDoesNotContaminateSubsequentCompile) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED();
+
+    auto model = ov::test::utils::make_conv_pool_relu();
+    ov::Core ie;
+
+    // if the log level leaks, the second compile will produce WARNING logs and the test will fail
+    utils::LoggerLevelGuard levelGuard(ov::log::Level::ERR);
+    const ov::log::Level baseline = ov::log::Level::ERR;
+
+    {
+        utils::LogCallbackGuard silentGuard(nullptr);
+        OV_ASSERT_NO_THROW(ie.compile_model(model, target_device, ov::AnyMap{ov::log::level(ov::log::Level::WARNING)}));
+    }
+    ASSERT_EQ(::intel_npu::Logger::global().level(), baseline)
+        << "Per-call log::level(WARNING) contaminated Logger::global() after compile_model returned";
+
+    std::string secondCompileLogs;
+    {
+        utils::LogCallbackGuard captureGuard([&](std::string_view m) {
+            secondCompileLogs.append(m);
+            secondCompileLogs.push_back('\n');
+        });
+        OV_ASSERT_NO_THROW(ie.compile_model(model, target_device));
+    }
+    EXPECT_EQ(secondCompileLogs.find("[WARNING]"), std::string::npos)
+        << "Per-call log::level(WARNING) from first compile contaminated the second compile.\n"
+           "Captured output snippet:\n"
+        << secondCompileLogs.substr(0, 500);
+}
+
 #ifdef OPENVINO_ENABLE_UNICODE_PATH_SUPPORT
 
 TEST_P(OVClassBasicTestPNPU, smoke_registerPluginsLibrariesUnicodePath) {
diff --git a/src/plugins/intel_npu/tests/functional/internal/compiler_adapter/zero_graph.hpp b/src/plugins/intel_npu/tests/functional/internal/compiler_adapter/zero_graph.hpp
index a0ec07d87bf9..277673662274 100644
--- a/src/plugins/intel_npu/tests/functional/internal/compiler_adapter/zero_graph.hpp
+++ b/src/plugins/intel_npu/tests/functional/internal/compiler_adapter/zero_graph.hpp
@@ -81,6 +81,7 @@ class ZeroGraphTest : public ::testing::TestWithParam<CompilationParamsAndExtens
 
 protected:
     void SetUp() override {
+        _logGuard.emplace(ov::log::Level::ERR);
         SKIP_IF_CURRENT_TEST_IS_DISABLED();
 
         std::tie(targetDevice, configuration, zeGraphNpuExtVersion) = this->GetParam();
@@ -102,6 +103,7 @@ class ZeroGraphTest : public ::testing::TestWithParam<CompilationParamsAndExtens
         if (blob) {
             ::operator delete(blob, std::align_val_t(::utils::STANDARD_PAGE_SIZE));
         }
+        _logGuard.reset();
     }
 
     void serializeIR() {
@@ -152,6 +154,7 @@ class ZeroGraphTest : public ::testing::TestWithParam<CompilationParamsAndExtens
     std::string targetDevice;
     std::string blobPath;
     uint32_t zeGraphNpuExtVersion;
+    std::optional<utils::LoggerLevelGuard> _logGuard;
 };
 
 using ZeroGraphCompilationTests = ZeroGraphTest;