Assume that all elements are distinct (if not, replace each element with a pair $(element, position)$ and perform the comparisons lexicographically) and consider a rooted binary tree $T$ with $n$ leaves in which each vertex has either $0$ or two children and every level, except possibly the last, is completely filled. Arbitrarily associate each leaf of $T$ with a distinct input element.
You can find the minimum by computing, for each interval vertex $v$, the minimum among all the elements associated to the leaves of the subtree of $T$ rooted at $v$. This can be done by performing a postorder visit of $T$: whenever $v$ is visited, let $v_\ell$ and $v_r$ be its two children, compare the elements associated with $v_\ell$ and $v_r$ and let the minimum among the two be the winner; the element associated with $v$ is exactly such winner.
At the end of the visit, the root of the tree will be associated with the minimum element of the input sequence.
Consider now the set $P$ of the vertices that have been associated with the minimum element and notice that they induce a root-to-leaf path in $T$. Let $C(P)$ denote the set of all children of the vertices in $P$.
Since the second-smallest element $x$ can only lose against the minimum element, there must be a vertex associated with $x$ among those in $C(P) \setminus P$ (and this set contains no vertex associated with the minimum element).
Then, you find the second-minimum of the input sequence be looking for the minimum of the elements associated with the vertices in $C(P) \setminus P$.
The overall number of comparisons is given by the sum of 1) the number of comparisons used to find the minimum, and 2) the number of comparisons needed to handle $C(P) \setminus P$. Regarding 1), we perform exactly $1$ comparison for each internal vertex, for a total of $n-1$ comparisons. Regarding 2), we perform $|C(P) \setminus P| - 1$ comparisons, where $|C(P) \setminus P|$ is at most the depth of $T$, i.e., $|C(P) \setminus P| \le \lceil \log n \rceil$. Then:
$$
(n-1) + (|C(P) \setminus P|-1) \le (n-1) + (\lceil \log n \rceil - 1) = n + \lceil \log n \rceil - 2.
$$
The above is this is just a handy description for the analysis of the number of comparison. You don't actually need to build and traverse the tree $T$. Here is a possible recursive implementation:
Input: a non-empty list L of distinct elements
Output: the second-minimum in L
Second-Minimum(L):
(x, S) = Find-Candidates(L)
Return the minimum in S
Input: a non-empty list L of distinct elements
Output: a pair (x, S), where x is the minimum in L, and S is a set of candidate second-minimum elements
Find-Candidates(L):
If |L|==1:
return (x, {}), where x is the only element in L
Split L into L' and L'' with | |L'| - |L''| | <= 1
(x', S') = Find-Candidates(L')
(x'', S'') = Find-Candidates(L'')
If x' < x'':
Return (x', S' U {x''})
Else:
Return (x'', S'' U {x'})