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;