SubClass Reference becomes BaseClass after Serialization

I hope the title is not misleading because I assume it has to do with Serialization

I have a ScriptableObject Asset-file that stores data for a tool Im writing.

 public class Graph : ScriptableObject {
      public List<GraphObject> graphObjects = new List<GraphObject> ();
 }

And a Base <----> Subclass structure

 [System.Serializable]
 public class GraphObject {
       [...] variables that work and get serialized fine[...]
 
      public void RegisterEvents () {
           GraphEditor.OnGraphUpdate += OnGraphUpdate;
      }
 
      protected virtual void OnGraphUpdate () { 
           Debug.Log("BaseclassReceivesUpdate");
      }
 }

 [System.Serializable]
 public class GraphNode : GraphObject {

      protected override void OnGraphUpdate () {
           Debug.Log("SubclassReceivesUpdate");
      }
 }

I now store a new GraphObject in the Graphs List but as Subclass and call RegisterEvents();

 GraphNode node = new GraphNode ();
 graphObjects.Add (node);
 node.RegisterEvents();

This actually calls the RegisterEvents(): on the Base class but adds the subclasses override OnGraphUpdate to the event. This is intended! Because when I now fire the event the subclass Updates. The base does nothing.

The problem is, when I now close the editor (I do set the Graph Dirty and Save etc. That part works) and re-open it, the List doesnt hold the subClasses anymore, but the base class Type. (Obviously the same as the Type the List was declared with).

When I now look through the List a GetType(); doesn't return "GraphNode" anymore but "GraphObject". RegisterEvents() called on a list-entry will now register the base classes "OnGraphUpdate" and prints "BaseClassUpdate". This is not what I want. I want to keep the reference to the subclass that I originally stored in the list and not have it changed to its baseClass type.

Did the re-serialization somehow do this? Because without editor restart it works fine. Is what I'm trying to do even possible that way?

As a possible solution I will try to create an Interface and store that in a List<[Interface]>. Because the whole point is that I dont want to know whats in that list. I want people to create their own Nodes and just derive from GraphObject. And the system automatically provides them with things like the OnGraphUpdate override method without them having to worry about registration etc