diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
index c741727..2e675cb 100644
--- a/extensions/openpower-pels/pel.cpp
+++ b/extensions/openpower-pels/pel.cpp
@@ -50,7 +50,7 @@
 {
     _ph = std::make_unique<PrivateHeader>(regEntry.componentID, obmcLogID,
                                           timestamp);
-    _uh = std::make_unique<UserHeader>(regEntry, severity);
+    _uh = std::make_unique<UserHeader>(regEntry, severity, dataIface);
 
     auto src = std::make_unique<SRC>(regEntry, additionalData, dataIface);
 
diff --git a/extensions/openpower-pels/registry.cpp b/extensions/openpower-pels/registry.cpp
index a02bebb..9b2262d 100644
--- a/extensions/openpower-pels/registry.cpp
+++ b/extensions/openpower-pels/registry.cpp
@@ -68,6 +68,41 @@
     return std::get<pv::fieldValuePos>(*s);
 }
 
+std::vector<RegistrySeverity> getSeverities(const nlohmann::json& severity)
+{
+    std::vector<RegistrySeverity> severities;
+
+    // The plain string value, like "unrecoverable"
+    if (severity.is_string())
+    {
+        RegistrySeverity s;
+        s.severity = getSeverity(severity.get<std::string>());
+        severities.push_back(std::move(s));
+    }
+    else
+    {
+        // An array, with an element like:
+        // {
+        //    "SevValue": "unrecoverable",
+        //    "System", "systemA"
+        // }
+        for (const auto& sev : severity)
+        {
+            RegistrySeverity s;
+            s.severity = getSeverity(sev["SevValue"].get<std::string>());
+
+            if (sev.contains("System"))
+            {
+                s.system = sev["System"].get<std::string>();
+            }
+
+            severities.push_back(std::move(s));
+        }
+    }
+
+    return severities;
+}
+
 uint16_t getActionFlags(const std::vector<std::string>& flags)
 {
     uint16_t actionFlags = 0;
@@ -573,12 +608,12 @@
 
             if (e->contains("Severity"))
             {
-                entry.severity = helper::getSeverity((*e)["Severity"]);
+                entry.severity = helper::getSeverities((*e)["Severity"]);
             }
 
             if (e->contains("MfgSeverity"))
             {
-                entry.mfgSeverity = helper::getSeverity((*e)["MfgSeverity"]);
+                entry.mfgSeverity = helper::getSeverities((*e)["MfgSeverity"]);
             }
 
             if (e->contains("EventType"))
diff --git a/extensions/openpower-pels/registry.hpp b/extensions/openpower-pels/registry.hpp
index 047853d..b145311 100644
--- a/extensions/openpower-pels/registry.hpp
+++ b/extensions/openpower-pels/registry.hpp
@@ -22,6 +22,18 @@
 };
 
 /**
+ * @brief A possible severity/system type combination
+ *
+ * If there is no system type defined for this entry,
+ * then the system field will be empty.
+ */
+struct RegistrySeverity
+{
+    std::string system;
+    uint8_t severity;
+};
+
+/**
  * @brief Represents the Documentation related fields in the message registry.
  *        It is part of the 'Entry' structure that will be filled in when
  *        an error is looked up in the registry.
@@ -122,14 +134,17 @@
     /**
      * @brief The optional PEL severity field.  If not specified, the PEL
      *        will use the severity of the OpenBMC event log.
+     *
+     * If the system type is specified in any of the entries in the vector,
+     * then the system type will be needed to find the actual severity.
      */
-    std::optional<uint8_t> severity;
+    std::optional<std::vector<RegistrySeverity>> severity;
 
     /**
      * @brief The optional severity field to use when in manufacturing tolerance
-     *        mode.
+     *        mode.  It behaves like the severity field above.
      */
-    std::optional<uint8_t> mfgSeverity;
+    std::optional<std::vector<RegistrySeverity>> mfgSeverity;
 
     /**
      * @brief The PEL action flags field.
@@ -319,6 +334,30 @@
 uint8_t getSeverity(const std::string& severityName);
 
 /**
+ * @brief Returns all of the system type/severity values found
+ * in the severity JSON passed in.
+ *
+ * The JSON is either a simple string, like:
+ *     "unrecoverable"
+ * or an array of system type/severity pairs, like:
+ *     [
+ *        {
+ *            "System": "1",
+ *            "SevValue": "predictive"
+ *        },
+ *        {
+ *            "System": "2",
+ *            "SevValue": "recovered"
+ *        }
+ *     ]
+ *
+ * @param[in] severity - The severity JSON
+ * @return The list of severity/system combinations.  If the System key
+ *         wasn't used, then that field will be empty in the structure.
+ */
+std::vector<RegistrySeverity> getSeverities(const nlohmann::json& severity);
+
+/**
  * @brief A helper function to get the action flags value based on
  *        the action flag names used in the registry.
  *
diff --git a/extensions/openpower-pels/user_header.cpp b/extensions/openpower-pels/user_header.cpp
index 8984dc7..07c3de3 100644
--- a/extensions/openpower-pels/user_header.cpp
+++ b/extensions/openpower-pels/user_header.cpp
@@ -46,7 +46,8 @@
 }
 
 UserHeader::UserHeader(const message::Entry& entry,
-                       phosphor::logging::Entry::Level severity)
+                       phosphor::logging::Entry::Level severity,
+                       const DataInterfaceBase& dataIface)
 {
     _header.id = static_cast<uint16_t>(SectionID::userHeader);
     _header.size = UserHeader::flattenedSize();
@@ -61,8 +62,32 @@
 
     // Get the severity from the registry if it's there, otherwise get it
     // from the OpenBMC event log severity value.
-    _eventSeverity =
-        entry.severity.value_or(convertOBMCSeverityToPEL(severity));
+    if (!entry.severity)
+    {
+        _eventSeverity = convertOBMCSeverityToPEL(severity);
+    }
+    else
+    {
+        // Find the severity possibly dependent on the system type.
+        auto sev =
+            getSeverity(entry.severity.value(), dataIface.getSystemType());
+        if (sev)
+        {
+            _eventSeverity = *sev;
+        }
+        else
+        {
+            // Someone screwed up the message registry.
+            log<level::ERR>(
+                "No severity entry found for this error and system type",
+                phosphor::logging::entry("ERROR=%s", entry.name.c_str()),
+                phosphor::logging::entry("SYSTEMTYPE=%s",
+                                         dataIface.getSystemType().c_str()));
+
+            // Have to choose something, just use informational.
+            _eventSeverity = 0;
+        }
+    }
 
     // TODO: ibm-dev/dev/#1144 Handle manufacturing sev & action flags
 
@@ -166,5 +191,35 @@
     uh.erase(uh.size() - 2);
     return uh;
 }
+
+std::optional<uint8_t> UserHeader::getSeverity(
+    const std::vector<message::RegistrySeverity>& severities,
+    const std::string& systemType) const
+{
+    const uint8_t* s = nullptr;
+
+    // Find the severity to use for this system type, or use the default
+    // entry (where no system type is specified).
+    for (const auto& sev : severities)
+    {
+        if (sev.system == systemType)
+        {
+            s = &sev.severity;
+            break;
+        }
+        else if (sev.system.empty())
+        {
+            s = &sev.severity;
+        }
+    }
+
+    if (s)
+    {
+        return *s;
+    }
+
+    return std::nullopt;
+}
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/user_header.hpp b/extensions/openpower-pels/user_header.hpp
index f1fc66d..a033ac0 100644
--- a/extensions/openpower-pels/user_header.hpp
+++ b/extensions/openpower-pels/user_header.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "data_interface.hpp"
 #include "elog_entry.hpp"
 #include "pel_values.hpp"
 #include "registry.hpp"
@@ -42,9 +43,11 @@
      *
      * @param[in] entry - The message registry entry for this error
      * @param[in] severity - The OpenBMC event log severity for this error
+     * @param[in] dataIface - The DataInterface object
      */
     UserHeader(const message::Entry& entry,
-               phosphor::logging::Entry::Level severity);
+               phosphor::logging::Entry::Level severity,
+               const DataInterfaceBase& dataIface);
 
     /**
      * @brief Constructor
@@ -233,6 +236,20 @@
     void validate() override;
 
     /**
+     * @brief Returns the severity value to use from the list
+     *        of them passed in based on the system type.
+     *
+     * If there isn't an entry found for the current system
+     * type then std::nullopt will be returned.
+     *
+     * @param[in] severities - The array of {systype, severity}
+     *                         structures to find an entry in.
+     * @param[in] systemType - The system type from DataInterface.
+     */
+    std::optional<uint8_t>
+        getSeverity(const std::vector<message::RegistrySeverity>& severities,
+                    const std::string& systemType) const;
+    /**
      * @brief The subsystem associated with the event.
      */
     uint8_t _eventSubsystem;
diff --git a/test/openpower-pels/registry_test.cpp b/test/openpower-pels/registry_test.cpp
index 92c1b14..ec930e9 100644
--- a/test/openpower-pels/registry_test.cpp
+++ b/test/openpower-pels/registry_test.cpp
@@ -48,7 +48,20 @@
         {
             "Name": "xyz.openbmc_project.Power.OverVoltage",
             "Subsystem": "power_control_hw",
-            "Severity": "unrecoverable",
+            "Severity":
+            [
+                {
+                    "System": "systemA",
+                    "SevValue": "unrecoverable"
+                },
+                {
+                    "System": "systemB",
+                    "SevValue": "recovered"
+                },
+                {
+                    "SevValue": "predictive"
+                }
+            ],
             "MfgSeverity": "non_error",
             "ActionFlags": ["service_action", "report", "call_home"],
             "MfgActionFlags": ["hidden"],
@@ -139,8 +152,18 @@
     ASSERT_TRUE(entry);
     EXPECT_EQ(entry->name, "xyz.openbmc_project.Power.OverVoltage");
     EXPECT_EQ(entry->subsystem, 0x62);
-    EXPECT_EQ(*(entry->severity), 0x40);
-    EXPECT_EQ(*(entry->mfgSeverity), 0x00);
+
+    ASSERT_EQ(entry->severity->size(), 3);
+    EXPECT_EQ((*entry->severity)[0].severity, 0x40);
+    EXPECT_EQ((*entry->severity)[0].system, "systemA");
+    EXPECT_EQ((*entry->severity)[1].severity, 0x10);
+    EXPECT_EQ((*entry->severity)[1].system, "systemB");
+    EXPECT_EQ((*entry->severity)[2].severity, 0x20);
+    EXPECT_EQ((*entry->severity)[2].system, "");
+
+    EXPECT_EQ(entry->mfgSeverity->size(), 1);
+    EXPECT_EQ((*entry->mfgSeverity)[0].severity, 0x00);
+
     EXPECT_EQ(*(entry->actionFlags), 0xA800);
     EXPECT_EQ(*(entry->mfgActionFlags), 0x4000);
     EXPECT_EQ(entry->componentID, 0x2300);
diff --git a/test/openpower-pels/user_header_test.cpp b/test/openpower-pels/user_header_test.cpp
index 7b8842c..f37b085 100644
--- a/test/openpower-pels/user_header_test.cpp
+++ b/test/openpower-pels/user_header_test.cpp
@@ -17,11 +17,13 @@
 #include "extensions/openpower-pels/pel_types.hpp"
 #include "extensions/openpower-pels/private_header.hpp"
 #include "extensions/openpower-pels/user_header.hpp"
+#include "mocks.hpp"
 #include "pel_utils.hpp"
 
 #include <gtest/gtest.h>
 
 using namespace openpower::pels;
+using ::testing::Return;
 
 TEST(UserHeaderTest, SizeTest)
 {
@@ -99,32 +101,74 @@
 TEST(UserHeaderTest, ConstructionTest)
 {
     using namespace openpower::pels::message;
-    Entry regEntry;
+    {
+        Entry regEntry;
 
-    regEntry.name = "test";
-    regEntry.subsystem = 5;
-    regEntry.severity = 0x40;
-    regEntry.actionFlags = 0xC000;
-    regEntry.eventType = 1;
-    regEntry.eventScope = 2;
+        regEntry.name = "test";
+        regEntry.subsystem = 5;
+        regEntry.severity = {{"", 0x40}};
+        regEntry.actionFlags = 0xC000;
+        regEntry.eventType = 1;
+        regEntry.eventScope = 2;
 
-    UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error);
+        MockDataInterface dataIface;
+        EXPECT_CALL(dataIface, getSystemType).WillOnce(Return("systemA"));
 
-    ASSERT_TRUE(uh.valid());
-    EXPECT_EQ(uh.header().id, 0x5548);
-    EXPECT_EQ(uh.header().size, UserHeader::flattenedSize());
-    EXPECT_EQ(uh.header().version, 0x01);
-    EXPECT_EQ(uh.header().subType, 0x00);
-    EXPECT_EQ(uh.header().componentID,
-              static_cast<uint16_t>(ComponentID::phosphorLogging));
+        UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
+                      dataIface);
 
-    ASSERT_EQ(uh.subsystem(), 5);
-    ASSERT_EQ(uh.severity(), 0x40);
-    ASSERT_EQ(uh.eventType(), 1);
-    ASSERT_EQ(uh.scope(), 2);
-    ASSERT_EQ(uh.problemDomain(), 0);
-    ASSERT_EQ(uh.problemVector(), 0);
-    ASSERT_EQ(uh.actionFlags(), 0xC000);
+        ASSERT_TRUE(uh.valid());
+        EXPECT_EQ(uh.header().id, 0x5548);
+        EXPECT_EQ(uh.header().size, UserHeader::flattenedSize());
+        EXPECT_EQ(uh.header().version, 0x01);
+        EXPECT_EQ(uh.header().subType, 0x00);
+        EXPECT_EQ(uh.header().componentID,
+                  static_cast<uint16_t>(ComponentID::phosphorLogging));
+
+        ASSERT_EQ(uh.subsystem(), 5);
+        ASSERT_EQ(uh.severity(), 0x40);
+        ASSERT_EQ(uh.eventType(), 1);
+        ASSERT_EQ(uh.scope(), 2);
+        ASSERT_EQ(uh.problemDomain(), 0);
+        ASSERT_EQ(uh.problemVector(), 0);
+        ASSERT_EQ(uh.actionFlags(), 0xC000);
+    }
+
+    // Test the system type based severity lookups
+    {
+        Entry regEntry;
+
+        regEntry.name = "test";
+        regEntry.subsystem = 5;
+        regEntry.severity = {{"", 0x20}, {"systemB", 0x10}, {"systemA", 0x00}};
+
+        MockDataInterface dataIface;
+        EXPECT_CALL(dataIface, getSystemType)
+            .WillOnce(Return("systemA"))
+            .WillOnce(Return("systemB"))
+            .WillOnce(Return("systemC"));
+
+        {
+            UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
+                          dataIface);
+
+            EXPECT_EQ(uh.severity(), 0x00);
+        }
+
+        {
+            UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
+                          dataIface);
+
+            EXPECT_EQ(uh.severity(), 0x10);
+        }
+
+        {
+            UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error,
+                          dataIface);
+
+            EXPECT_EQ(uh.severity(), 0x20);
+        }
+    }
 }
 
 // Test that the severity comes from the event log if not
@@ -141,7 +185,9 @@
     regEntry.eventScope = 2;
     // Leave off severity
 
-    UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error);
+    MockDataInterface dataIface;
+
+    UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, dataIface);
     ASSERT_EQ(uh.severity(), 0x40);
 }
 
@@ -153,10 +199,12 @@
 
     regEntry.name = "test";
     regEntry.subsystem = 5;
-    regEntry.severity = 0x40;
+    regEntry.severity = {{"", 0x40}};
     regEntry.actionFlags = 0xC000;
 
-    UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error);
+    MockDataInterface dataIface;
+
+    UserHeader uh(regEntry, phosphor::logging::Entry::Level::Error, dataIface);
 
     ASSERT_EQ(uh.eventType(), 0);
     ASSERT_EQ(uh.scope(), 0x03);