This can be solved by window functions:

select *
from (
   select *
   , row_number() over(partition by parentid order by case when effectivetimestamp <= Getdate() then 0 else 1 end, effectivetimestamp DESC) AS rnk
   FROM child
) c
where rnk = 1

row_number creates a column with values 1,2,3 depending on the group (partition) and order (order by).

So for every parent, we want to prioritize effective dates less than getdate at first hand, and finally the latest date.

where rnk = 1 gets us the latest child per parent

I would suggest a rewrite of the query using the CROSS APPLY (SELECT TOP 1 ... WHERE ... ORDER BY ...) pattern to select the active child with the most recent effective date, or latest future date, if there is no active child.

The trick is setting up the ORDER BY . The following will first sort on the "active" status, placing active rows first. It will the sort by effectivetimestamp descending to get either the latest active or the latest overall..

SELECT 
    p.id AS parentid,
    c.id,
    c.name,
    c.effectivetimestamp
FROM dbo.parent AS p
CROSS APPLY (
    SELECT TOP 1
        c.id,
        c.name,
        c.effectivetimestamp
    FROM dbo.child AS c
    WHERE c.parentid = p.id
    ORDER BY
        CASE WHEN c.effectivetimestamp <= GETDATE() THEN 1 ELSE 2 END, -- Active first
        c.effectivetimestamp DESC -- Latest active (or latest future)
) c
WHERE p.id IN (1, 2, 3, 4, 5, 99)

The above query always select the parent row and returns the parent id. The OUTER APPLY then looks up the most recent active child row. An OUTER APPLY is like a LEFT OUTER JOIN in that if no eligible child is found, it will yield NULL values, while the parent data will remain a part of the results.

Note that the above includes a reference to the parent table and requires a matching parent row to be present. To eliminate this dependency, the initial FROM dbo.parent AS p reference can be replaced with FROM (VALUES (1),(2),(3),(4),(5)) AS p(id) or an existing selected ID list table if you already have one. The WHERE clause could then be dropped.

This pattern is a common method in scenarios where you need to look up the "the best matching X" for a given criteria. General examples would be things like "effective price", "current employee salary", "latest available report" for a given date.

See this db<>fiddle for a demo.

Sample results (with a few extra columns).
| parentid | name | expected | id | name | effectivetimestamp |
| ------------ | ------------ | ------------ | ------------ | ------------ | ------------ |
| 1 | Parent-A | Child-A2 | 12 | Child-A2 | 2023-11-01 12:34 |
| 2 | Parent-B | Child-B1 | 21 | Child-B1 | 2023-02-01 08:00 |
| 3 | Parent-C | Child-C2 - latest future | 31 | Child-C2 | 2088-08-08 08:08 |
| 5 | Parent-E | Child-E2 (reverse id order) | 52 | Child-E2 | 2023-09-01 12:34 |

One option is to count a number of child elements first in a subquery and then apply your criteria

select top(1) with ties parentid id,
       name,
       effectivetimestamp
from (
    select id,
           name,
           effectivetimestamp,
           count(*) over(partition by parentid) cnt
    from  dbo.child 
    where parentid IN ( 1, 2, 3, 4, 5 )     
) t
where effectivetimestamp <= Getdate() or cnt=1
order by row_number() over(partition by parentid order by effectivetimestamp desc)

I think what you need is to use UNION operator to also get the childs that have a effectiveTimestamp > getDate

Check below query, it will output the desired result:

SELECT * FROM (SELECT parentid,
       child.id,
       name,
       child.effectivetimestamp
FROM   dbo.child AS child
       INNER JOIN (SELECT MAX([id])                AS id,
                          Max([effectivetimestamp]) AS effectiveTimestamp                   
                          FROM   dbo.child
                   WHERE  parentid IN ( 1, 2, 3, 4, 5 )
                          AND effectivetimestamp <= Getdate()
                   GROUP  BY parentid
                   UNION 
                   SELECT MAX([id])                 AS id,
                          Max([effectivetimestamp]) AS effectiveTimestamp        
                   FROM   dbo.child
                   WHERE  parentid not in (SELECT [parentid]                AS id                  
                          FROM   dbo.child
                   WHERE  parentid IN ( 1, 2, 3, 4, 5 )
                          AND effectivetimestamp <= Getdate() 
                   )
                            AND effectivetimestamp > Getdate()
                   group by parentid) AS effectiveVersion
               ON child.id = effectiveVersion.id)as T1