diff --git a/phosphor-regulators/src/error_logging_utils.cpp b/phosphor-regulators/src/error_logging_utils.cpp
new file mode 100644
index 0000000..fb3506e
--- /dev/null
+++ b/phosphor-regulators/src/error_logging_utils.cpp
@@ -0,0 +1,195 @@
+/**
+ * Copyright © 2021 IBM Corporation
+ *
+ * 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 "error_logging_utils.hpp"
+
+#include "config_file_parser_error.hpp"
+#include "exception_utils.hpp"
+#include "i2c_interface.hpp"
+#include "journal.hpp"
+#include "pmbus_error.hpp"
+#include "write_verification_error.hpp"
+
+#include <sdbusplus/exception.hpp>
+
+#include <vector>
+
+namespace phosphor::power::regulators::error_logging_utils
+{
+
+void logError(std::exception_ptr eptr, Entry::Level severity,
+              Services& services)
+{
+    // Specify empty error history so that all error types will be logged
+    ErrorHistory history{};
+    logError(eptr, severity, services, history);
+}
+
+void logError(std::exception_ptr eptr, Entry::Level severity,
+              Services& services, ErrorHistory& history)
+{
+    // Check for null exception pointer
+    if (!eptr)
+    {
+        return;
+    }
+
+    // Get exception to log from specified exception and any nested exceptions
+    std::exception_ptr exceptionToLog = internal::getExceptionToLog(eptr);
+
+    // Log an error based on the exception
+    ErrorLogging& errorLogging = services.getErrorLogging();
+    Journal& journal = services.getJournal();
+    ErrorType errorType{};
+    try
+    {
+        std::rethrow_exception(exceptionToLog);
+    }
+    catch (const ConfigFileParserError& e)
+    {
+        errorType = ErrorType::configFile;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logConfigFileError(severity, journal);
+        }
+    }
+    catch (const PMBusError& e)
+    {
+        errorType = ErrorType::pmbus;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logPMBusError(severity, journal, e.getInventoryPath());
+        }
+    }
+    catch (const WriteVerificationError& e)
+    {
+        errorType = ErrorType::writeVerification;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logWriteVerificationError(severity, journal,
+                                                   e.getInventoryPath());
+        }
+    }
+    catch (const i2c::I2CException& e)
+    {
+        errorType = ErrorType::i2c;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logI2CError(severity, journal, e.bus, e.addr,
+                                     e.errorCode);
+        }
+    }
+    catch (const sdbusplus::exception_t& e)
+    {
+        errorType = ErrorType::dbus;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logDBusError(severity, journal);
+        }
+    }
+    catch (const std::exception& e)
+    {
+        errorType = ErrorType::internal;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logInternalError(severity, journal);
+        }
+    }
+    catch (...)
+    {
+        errorType = ErrorType::internal;
+        if (!history.wasLogged(errorType))
+        {
+            history.setWasLogged(errorType, true);
+            errorLogging.logInternalError(severity, journal);
+        }
+    }
+}
+
+namespace internal
+{
+
+std::exception_ptr getExceptionToLog(std::exception_ptr eptr)
+{
+    // Default to selecting the outermost exception
+    std::exception_ptr exceptionToLog{eptr};
+
+    // Get vector containing this exception and any nested exceptions
+    std::vector<std::exception_ptr> exceptions =
+        exception_utils::getExceptions(eptr);
+
+    // Define temporary constants for exception priorities
+    const int lowPriority{0}, mediumPriority{1}, highPriority{2};
+
+    // Loop through the exceptions from innermost to outermost.  Find the
+    // exception with the highest priority.  If there is a tie, select the
+    // outermost exception with that priority.
+    int highestPriorityFound{-1};
+    for (std::exception_ptr curptr : exceptions)
+    {
+        int priority{-1};
+        try
+        {
+            std::rethrow_exception(curptr);
+        }
+        catch (const ConfigFileParserError& e)
+        {
+            priority = highPriority;
+        }
+        catch (const PMBusError& e)
+        {
+            priority = highPriority;
+        }
+        catch (const WriteVerificationError& e)
+        {
+            priority = highPriority;
+        }
+        catch (const i2c::I2CException& e)
+        {
+            priority = highPriority;
+        }
+        catch (const sdbusplus::exception_t& e)
+        {
+            priority = mediumPriority;
+        }
+        catch (const std::exception& e)
+        {
+            priority = lowPriority;
+        }
+        catch (...)
+        {
+            priority = lowPriority;
+        }
+
+        if (priority >= highestPriorityFound)
+        {
+            highestPriorityFound = priority;
+            exceptionToLog = curptr;
+        }
+    }
+
+    return exceptionToLog;
+}
+
+} // namespace internal
+
+} // namespace phosphor::power::regulators::error_logging_utils
diff --git a/phosphor-regulators/src/error_logging_utils.hpp b/phosphor-regulators/src/error_logging_utils.hpp
new file mode 100644
index 0000000..d90b2df
--- /dev/null
+++ b/phosphor-regulators/src/error_logging_utils.hpp
@@ -0,0 +1,85 @@
+/**
+ * Copyright © 2021 IBM Corporation
+ *
+ * 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.
+ */
+#pragma once
+
+#include "error_history.hpp"
+#include "error_logging.hpp"
+#include "services.hpp"
+
+#include <exception>
+
+/**
+ * @namespace error_logging_utils
+ *
+ * Contains utility functions for logging errors.
+ */
+namespace phosphor::power::regulators::error_logging_utils
+{
+
+/**
+ * Logs an error based on the specified exception and any nested inner
+ * exceptions.
+ *
+ * @param eptr exception pointer
+ * @param severity severity level
+ * @param services system services like error logging and the journal
+ */
+void logError(std::exception_ptr eptr, Entry::Level severity,
+              Services& services);
+
+/**
+ * Logs an error, if necessary, based on the specified exception and any nested
+ * inner exceptions.
+ *
+ * Finds the error type would be logged based on the specified exception and any
+ * nested inner exceptions.
+ *
+ * Checks to see if this error type has already been logged according to the
+ * specified ErrorHistory object.
+ *
+ * If the error type has not been logged, an error log entry is created, and the
+ * ErrorHistory is updated.
+ *
+ * If the error type has been logged, no further action is taken.
+ *
+ * @param eptr exception pointer
+ * @param severity severity level
+ * @param services system services like error logging and the journal
+ * @param history error logging history
+ */
+void logError(std::exception_ptr eptr, Entry::Level severity,
+              Services& services, ErrorHistory& history);
+
+/*
+ * Internal implementation details
+ */
+namespace internal
+{
+
+/**
+ * Returns the exception to use when logging an error.
+ *
+ * Inspects the specified exception and any nested inner exceptions.  Returns
+ * the highest priority exception from an error logging perspective.
+ *
+ * @param eptr exception pointer
+ * @return exception to log
+ */
+std::exception_ptr getExceptionToLog(std::exception_ptr eptr);
+
+} // namespace internal
+
+} // namespace phosphor::power::regulators::error_logging_utils
diff --git a/phosphor-regulators/src/meson.build b/phosphor-regulators/src/meson.build
index 9993591..40cb3e8 100644
--- a/phosphor-regulators/src/meson.build
+++ b/phosphor-regulators/src/meson.build
@@ -10,6 +10,7 @@
     'configuration.cpp',
     'device.cpp',
     'error_logging.cpp',
+    'error_logging_utils.cpp',
     'exception_utils.cpp',
     'ffdc_file.cpp',
     'id_map.cpp',
diff --git a/phosphor-regulators/test/error_logging_utils_tests.cpp b/phosphor-regulators/test/error_logging_utils_tests.cpp
new file mode 100644
index 0000000..f7665c0
--- /dev/null
+++ b/phosphor-regulators/test/error_logging_utils_tests.cpp
@@ -0,0 +1,719 @@
+/**
+ * Copyright © 2021 IBM Corporation
+ *
+ * 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 "config_file_parser_error.hpp"
+#include "error_logging.hpp"
+#include "error_logging_utils.hpp"
+#include "i2c_interface.hpp"
+#include "journal.hpp"
+#include "mock_error_logging.hpp"
+#include "mock_journal.hpp"
+#include "mock_services.hpp"
+#include "pmbus_error.hpp"
+#include "write_verification_error.hpp"
+
+#include <errno.h>
+
+#include <sdbusplus/exception.hpp>
+
+#include <exception>
+#include <filesystem>
+#include <stdexcept>
+#include <string>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace phosphor::power::regulators;
+
+namespace fs = std::filesystem;
+
+using ::testing::Ref;
+
+TEST(ErrorLoggingUtilsTests, LogError_3Parameters)
+{
+    // Create exception with two nesting levels; top priority is inner
+    // PMBusError
+    std::exception_ptr eptr;
+    try
+    {
+        try
+        {
+            throw PMBusError{"VOUT_MODE contains unsupported data format",
+                             "reg1",
+                             "/xyz/openbmc_project/inventory/system/chassis/"
+                             "motherboard/reg1"};
+        }
+        catch (...)
+        {
+            std::throw_with_nested(
+                std::runtime_error{"Unable to set output voltage"});
+        }
+    }
+    catch (...)
+    {
+        eptr = std::current_exception();
+    }
+
+    // Create MockServices.  Expect logPMBusError() to be called.
+    MockServices services{};
+    MockErrorLogging& errorLogging = services.getMockErrorLogging();
+    MockJournal& journal = services.getMockJournal();
+    EXPECT_CALL(
+        errorLogging,
+        logPMBusError(
+            Entry::Level::Error, Ref(journal),
+            "/xyz/openbmc_project/inventory/system/chassis/motherboard/reg1"))
+        .Times(1);
+
+    // Log error based on the nested exception
+    error_logging_utils::logError(eptr, Entry::Level::Error, services);
+}
+
+TEST(ErrorLoggingUtilsTests, LogError_4Parameters)
+{
+    // Test where exception pointer is null
+    {
+        std::exception_ptr eptr;
+
+        // Create MockServices.  Don't expect any log*() methods to be called.
+        MockServices services{};
+
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+    }
+
+    // Test where exception is not nested
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw i2c::I2CException{"Unable to open device reg1", "/dev/i2c-8",
+                                    0x30, ENODEV};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logI2CError() to be called.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logI2CError(Entry::Level::Critical, Ref(journal),
+                                "/dev/i2c-8", 0x30, ENODEV))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Critical, services,
+                                      history);
+    }
+
+    // Test where exception is nested
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            try
+            {
+                throw std::invalid_argument{"JSON element is not an array"};
+            }
+            catch (...)
+            {
+                std::throw_with_nested(ConfigFileParserError{
+                    fs::path{"/etc/phosphor-regulators/config.json"},
+                    "Unable to parse JSON configuration file"});
+            }
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logConfigFileError() to be called.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logConfigFileError(Entry::Level::Warning, Ref(journal)))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Warning, services,
+                                      history);
+    }
+
+    // Test where exception is a ConfigFileParserError
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw ConfigFileParserError{
+                fs::path{"/etc/phosphor-regulators/config.json"},
+                "Unable to parse JSON configuration file"};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logConfigFileError() to be called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logConfigFileError(Entry::Level::Error, Ref(journal)))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+    }
+
+    // Test where exception is a PMBusError
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw PMBusError{"VOUT_MODE contains unsupported data format",
+                             "reg1",
+                             "/xyz/openbmc_project/inventory/system/chassis/"
+                             "motherboard/reg1"};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logPMBusError() to be called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logPMBusError(Entry::Level::Error, Ref(journal),
+                                  "/xyz/openbmc_project/inventory/system/"
+                                  "chassis/motherboard/reg1"))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+    }
+
+    // Test where exception is a WriteVerificationError
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw WriteVerificationError{
+                "value_written: 0xDEAD, value_read: 0xBEEF", "reg1",
+                "/xyz/openbmc_project/inventory/system/chassis/motherboard/"
+                "reg1"};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logWriteVerificationError() to be
+        // called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging, logWriteVerificationError(
+                                      Entry::Level::Warning, Ref(journal),
+                                      "/xyz/openbmc_project/inventory/system/"
+                                      "chassis/motherboard/reg1"))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Warning, services,
+                                      history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Warning, services,
+                                      history);
+    }
+
+    // Test where exception is a I2CException
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw i2c::I2CException{"Unable to open device reg1", "/dev/i2c-8",
+                                    0x30, ENODEV};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logI2CError() to be called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logI2CError(Entry::Level::Informational, Ref(journal),
+                                "/dev/i2c-8", 0x30, ENODEV))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Informational,
+                                      services, history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Informational,
+                                      services, history);
+    }
+
+    // Test where exception is a sdbusplus::exception_t
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            // Throw InvalidEnumString; exception_t is a pure virtual base class
+            throw sdbusplus::exception::InvalidEnumString{};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logDBusError() to be called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logDBusError(Entry::Level::Debug, Ref(journal)))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Debug, services,
+                                      history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Debug, services,
+                                      history);
+    }
+
+    // Test where exception is a std::exception
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw std::runtime_error{
+                "Unable to read configuration file: No such file or directory"};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logInternalError() to be called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logInternalError(Entry::Level::Error, Ref(journal)))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Error, services,
+                                      history);
+    }
+
+    // Test where exception is unknown type
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw 23;
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        // Create MockServices.  Expect logInternalError() to be called once.
+        MockServices services{};
+        MockErrorLogging& errorLogging = services.getMockErrorLogging();
+        MockJournal& journal = services.getMockJournal();
+        EXPECT_CALL(errorLogging,
+                    logInternalError(Entry::Level::Warning, Ref(journal)))
+            .Times(1);
+
+        // Log error based on the nested exception
+        ErrorHistory history{};
+        error_logging_utils::logError(eptr, Entry::Level::Warning, services,
+                                      history);
+
+        // Try to log error again.  Should not happen due to ErrorHistory.
+        error_logging_utils::logError(eptr, Entry::Level::Warning, services,
+                                      history);
+    }
+}
+
+TEST(ErrorLoggingUtilsTests, GetExceptionToLog)
+{
+    // Test where exception is not nested
+    {
+        std::exception_ptr eptr;
+        try
+        {
+            throw i2c::I2CException{"Unable to open device reg1", "/dev/i2c-8",
+                                    0x30, ENODEV};
+        }
+        catch (...)
+        {
+            eptr = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(eptr);
+        EXPECT_EQ(eptr, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is innermost exception
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw PMBusError{
+                    "VOUT_MODE contains unsupported data format", "reg1",
+                    "/xyz/openbmc_project/inventory/system/chassis/"
+                    "motherboard/reg1"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable to set output voltage"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(inner, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is middle exception
+    {
+        std::exception_ptr inner, middle, outer;
+        try
+        {
+            try
+            {
+                try
+                {
+                    throw std::invalid_argument{"JSON element is not an array"};
+                }
+                catch (...)
+                {
+                    inner = std::current_exception();
+                    std::throw_with_nested(ConfigFileParserError{
+                        fs::path{"/etc/phosphor-regulators/config.json"},
+                        "Unable to parse JSON configuration file"});
+                }
+            }
+            catch (...)
+            {
+                middle = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable to load config file"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(middle, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is outermost exception
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw std::invalid_argument{"JSON element is not an array"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(ConfigFileParserError{
+                    fs::path{"/etc/phosphor-regulators/config.json"},
+                    "Unable to parse JSON configuration file"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(outer, exceptionToLog);
+    }
+
+    // Test where exception is nested: Two exceptions have same priority.
+    // Should return outermost exception with that priority.
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw std::invalid_argument{"JSON element is not an array"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable to load config file"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(outer, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is ConfigFileParserError
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw ConfigFileParserError{
+                    fs::path{"/etc/phosphor-regulators/config.json"},
+                    "Unable to parse JSON configuration file"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable to load config file"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(inner, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is PMBusError
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw std::invalid_argument{"Invalid VOUT_MODE value"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(PMBusError{
+                    "VOUT_MODE contains unsupported data format", "reg1",
+                    "/xyz/openbmc_project/inventory/system/chassis/motherboard/"
+                    "reg1"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(outer, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is
+    // WriteVerificationError
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw WriteVerificationError{
+                    "value_written: 0xDEAD, value_read: 0xBEEF", "reg1",
+                    "/xyz/openbmc_project/inventory/system/chassis/motherboard/"
+                    "reg1"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable set voltage"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(inner, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is I2CException
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw std::invalid_argument{"No such device"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(i2c::I2CException{
+                    "Unable to open device reg1", "/dev/i2c-8", 0x30, ENODEV});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(outer, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is
+    // sdbusplus::exception_t
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                // Throw InvalidEnumString; exception_t is pure virtual class
+                throw sdbusplus::exception::InvalidEnumString{};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable to call D-Bus method"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(inner, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is std::exception
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw std::invalid_argument{"No such file or directory"};
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(
+                    std::runtime_error{"Unable load config file"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(outer, exceptionToLog);
+    }
+
+    // Test where exception is nested: Highest priority is unknown type
+    {
+        std::exception_ptr inner, outer;
+        try
+        {
+            try
+            {
+                throw 23;
+            }
+            catch (...)
+            {
+                inner = std::current_exception();
+                std::throw_with_nested(std::string{"Unable load config file"});
+            }
+        }
+        catch (...)
+        {
+            outer = std::current_exception();
+        }
+
+        std::exception_ptr exceptionToLog =
+            error_logging_utils::internal::getExceptionToLog(outer);
+        EXPECT_EQ(outer, exceptionToLog);
+    }
+}
diff --git a/phosphor-regulators/test/meson.build b/phosphor-regulators/test/meson.build
index b36ff1a..0fd55de 100644
--- a/phosphor-regulators/test/meson.build
+++ b/phosphor-regulators/test/meson.build
@@ -10,6 +10,7 @@
     'configuration_tests.cpp',
     'device_tests.cpp',
     'error_history_tests.cpp',
+    'error_logging_utils_tests.cpp',
     'exception_utils_tests.cpp',
     'ffdc_file_tests.cpp',
     'id_map_tests.cpp',