C++ merging sorted linked lists I'd like to see if there's any code reuse I'm missing, or anything else that can be rewritten in a better way, but always following the same data structures (without adding more classes or using the C++ list implementation).

Node* merge(Node* list1, Node* list2){
    if (list1 == nullptr){
        return list2;
    }
    else{
        if (list2 == nullptr){
            return list1;
        }
        else{
            Node* newList = nullptr;
            if (list1-&gt;data &lt;= list2-&gt;data){
                newList = list1;
            }
            else{
                newList = list2;
            }
            while (list1-&gt;next != nullptr) {
                if (list1-&gt;next-&gt;data &gt; list2-&gt;data){
                    Node* aux = list1-&gt;next;
                    list1-&gt;next = list2;
                    list2 = aux;
                }
                list1 = list1-&gt;next;
            }
            if (list1-&gt;next == nullptr){
                list1-&gt;next = list2;
            }
            return newList;
        }
    }
}
I would do a couple of things differently.
Early escape
Your use of early escape is good and makes the code easier to read but you don't need the else section if the body of if statement returns.
Node* merge(Node* list1, Node* list2)
{
    if (list1 == nullptr){
        return list2;
    }
    if (list2 == nullptr){
        return list1;
    }
    // Main body of code.

This is quite normal. It reduces the number of level of indenting and makes the code look clean.
Self documenting code
I would encourage you to split getting the next item into a separate function (this facilitates self documenting code).
Node* getNextNode(Node*&amp; list1, Node*&amp; list2)
{
    // Work out which list has the smallest value.
    Node*&amp; smallList = (list1-&gt;data &lt; list2-&gt;data) ? list1 : list2;

    // The head of this list is the result
    Node* result = smallList;

    // Move the list to the next value (notice the call be reference).
    smallList = smallList-&gt;next;

    return result;
}

Simplified Body
Now if we rewrite the main body of your code in terms of this helper function;
Node* result  = getNextNode(list1, list2);
Node* current = result;

// Looping over the list until one is empty
// becomes very trivial now.
while(list1 != nullptr &amp;&amp; list2 != nullptr)
{
     // Get next node and remove it from its list.
     Node* next    = getNextNode(list1, list2);
     current-&gt;next = next;
     current       = next;
}

// One of the lists is empty.
// Add what is left of the other list on the end (ie after current).
current-&gt;next = (list1 == nullptr) ? list2 : list1;
return result;