
<p class="has-drop-cap wp-block-paragraph">1C.Th. Ericssons Memorial är ett av Solvallas verkligt traditionsfyllda lopp. Loppet kördes för första gången 1933, två år efter ”Cetes” död.</p>



<p class="wp-block-paragraph">Carl Theodor Ericsson (1863–1931) var med redan innan det började på Solvalla. Han satt i styrelsen för Svenska Trafvarsällskapet (Brunnsviken) och sedermera Stockholms Travsällskap. Dit kom han som framgångsrik grosshandlare och fastighetsägare, och som hästägare blev han vinstrikast av alla på Solvalla 1930. Det står att läsa på Nordiska Travmuséets hemsida.</p>



<p class="wp-block-paragraph">Precis som de senaste åren är loppets prissumma upphöjd en hel del. Med anledning av att det inte kördes någon gulddivisionsfinal i årets första STL-meeting, så väntar hela 500.000 kronor på vinnaren när årets upplaga avgörs på lördag.<br>Men det är inte starkaste kryddan – C.Th. Ericssons Memorial är nämligen det första loppet i nya E-loppsserien, där sju lopp för högsta klassen i Sverige i vår ska plocka fram två Elitloppshästar enligt poängberäkning.</p>



<p class="wp-block-paragraph">Två hästar i lördagens lopp har redan gjort stora avtryck i självaste Elitloppet. Elisabeth Almhedens sagohäst <strong>A Fair Day</strong> (e. Maharajah) tog revansch efter galoppen 2024 genom att sluta fyra i Elitloppsfinalen förra året. Till samma final hade Daniel Wäjerstens <strong>Mellby Jinx</strong> (e. Ready Cash) tagit sig efter att ha satt svenskt rekord vid spetssegern i försöket, 1.08,8a/1.609 meter.<br>Mellby Jinx är också titelförsvarare i C.Th. Ericssons Memorial, som sedan 2019 har avgjorts över medeldistans med startbil i slutet av mars på Solvalla.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/03/10mellbyjinx1-617x333.jpg" alt="" class="wp-image-700808"/><figcaption class="wp-element-caption">Mellby Jinx och Daniel Wäjersten vid segern i C.Th.Ericssons Memorial ifjol. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Senaste vinnarna av ”Cetes”</strong>:<br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2019 <strong>Milligan’s School</strong> (e. Yankee Glide) – Ulf Eriksson (Stefan Melander) – 1.11,6a</li>



<li>2020 <strong>Disco Volante</strong> (e. Scarlet Knight) – Ulf Ohlsson (Stefan Melander) – 1.10,9a</li>



<li>2021 <strong>Disco Volante</strong> (e. Scarlet Knight) – Ulf Ohlsson (Stefan Melander) – 1.11,7a</li>



<li>2022 <strong>Stoletheshow</strong> (e. Dream Vacation) – Björn Goop (Frode Hamre) – 1.11,7a</li>



<li>2023 <strong>Aetos Kronos</strong> (e. Bold Eagle) – Magnus A Djuse (Jerry Riordan) – 1.12,1a</li>



<li>2024 <strong>Phoenix Photo</strong> (e. Super Photo Kosmos) – Björn Goop (Svante Ericsson) – 1.11,1a</li>



<li>2025 <strong>Mellby Jinx</strong> (e. Ready Cash) – Daniel Wäjersten – 1.11,2a</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2Lika segervan som otursförföljd och skadedrabbad. <strong>Punchboard</strong> (e. Readly Express) har hunnit bli åtta år, men bara hunnit med 18 starter i karriären när han ikväll på Bergsåker (första start 18.20) gör årsdebut och första framträdandet sedan september ifjol.</p>



<p class="wp-block-paragraph">Punchboard inledde hos Svante Båth med fyra segrar och två andrapris på sex starter. På hösten som fyraåring gick han i träning hos Daniel Wäjersten, men det dröjde nästan två år innan han var tillbaka på banan.<br>Tre segrar (varav en i rikstoton) på fyra starter blev det första korta säsongen hos Wäjersten. Ifjol kunde Punchboard tävla mer och räknade in fyra nya vinster på åtta försök, innan han fick strykas för hälta från en tilltänkt start i Boden i oktober.</p>



<p class="wp-block-paragraph">Nu görs alltså ett nytt försök med den högkapable fuxen när han kommer ut från tillägg i ett dubbelklasslopp med åtta konkurrenter i jakten på att ordna dussinet fullt i segerkolumnen.</p>



<p class="wp-block-paragraph">En annan spännande årsdebutant från Wäjersten är dubbelmiljonären <strong>Lando Mearas</strong> (e. Walner), som inleder femåringssäsongen i snabbloppet. Hästen vann försök till både Svenskt Travkriterium och Kungapokalen som unghäst och är nu redo att möta den äldre eliten.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2023/04/verykronoseam230405adamstromstalltz-617x384.jpg" alt="" class="wp-image-427412" style="width:617px;height:auto"/><figcaption class="wp-element-caption">Världsrekordtravaren Very Kronos. Foto Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3<strong>Very Kronos </strong>(e. Ready Cash), 1.10,7ak/7.322.559 kr, var en storstjärna på tävlingsbanan i Svante Båths regi med miljonsegern i Sundsvall Open Trot 2021 som absolut höjdare. Han blev också dubbel svensk mästare och slutade tvåa i Paralympiatravet.</p>



<p class="wp-block-paragraph">Medan tävlingskarriären fortfarande pågick klev han in i avelsboxen för första gången 2022 och året efter föddes 18 svenska avkommor. På Bergsåker ikväll är det dags för första starthästen när dottern <strong>Very Li</strong> kommer ut i nolloppen tillsammans med sin tränare Daniel Wäjersten.<br>Very Li kvalade för en månad sedan och har en meriterad mamma i finskfödda <strong>Stoneisle Lilian</strong> (e. S.J.’s Caviar), 1.12,4ak/1.891.661 kr, som vann 16 lopp.</p>



<p class="wp-block-paragraph">Very Kronos fick några få avkommor 2024 (fyra), medan fjolårskullen innehåller 35 svenska avkommor.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4Nästan trekvarts miljon kronor travade Maria Törnqvist-tränade <strong>Fawas Mil</strong> (e. Gu d’Heripre) in förra året som fyraåring och klev rejält i klasserna. Detta efter bland annat en seger och två andraplatser inom rikstoton.<br>På dagens lunchbana Färjestad (första start 12.20) är det dags för årsdebut och ett möte med bland annat <strong>Cameron Hills</strong> (e. Muscle Hill) och <strong>Michigan Bro</strong> (e. S.J.’s Caviar), som båda vunnit lopp i mars.</p>



<p class="wp-block-paragraph">En V85-vinnare från mellandagarna förra året i Gävle gör årsdebut i ett lärlingslopp, Fredrik Wallin-tränade <strong>Xanthis Joojoo</strong> (e. Googoo Gaagaa), som får Hugo Metayer i vagnen. Hästen tvingades strykas från stodivisionsfinalen på Solvalla i början av februari och kommer nu från tre månaders tävlingsuppehåll.</p>



<p class="wp-block-paragraph">Det tävlas på ytterligare en bana idag när Eskilstuna (första start 18.30) bjuder på breddlopp och nio fyllda lopp med tolv hästar i varje. Nästan 90 hästar anmäldes till delningspropositionen med 12.000 kronor i förstapris och 84 får chansen att tävla.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/03/260324.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till tisdagens tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5Två hästar är inbjudna till finska sprinterfesten Finlandia-Ajo på Vermo den 10 maj, där vinnaren får en biljett till Elitloppet. Båda är dessutom svenskfödda: Katja Melkkos <strong>High On Pepper</strong> (e. Ready Cash) och Antti Ojanperäs <strong>Combat Fighter</strong> (e. From Above).</p>



<p class="wp-block-paragraph">Den sistnämnde har efter en vinter i Paris – andra- och tredjeplats som näst och närmare 40.000 euro insprunget på sex starter – återvänt till Finland. Igår kväll startade han från tillägg i ett långlopp i Seinäjoki med Finlands kuskchampion Santtu Raitala i vagnen.</p>



<p class="wp-block-paragraph">Raitala valde ett defensivt inlägg och till varvet från mål satt Combat Fighter fastlåst i femte invändigt. Då backades hästen loss och 400 meter från mål klev Combat Fighter på i fjärdespår. Avståndet till Stefan Melander-uppfödde ledaren <strong>Overhead Panel</strong> (e. Uncle Lasse) var dock alldeles för stort och Combat Fighter fick nöja sig med tredjepriset och 600 euro på 1.16,0/2.620 meter. Vinnande Overhead Panel noterade 1.16,5/2.600 meter när han tog andra raka segern på kort tid efter halvårslångt uppehåll.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/03/daveingraham.png" alt="" class="wp-image-830035"/><figcaption class="wp-element-caption">Dave Ingraham har tagit seger 8.000 i kuskkarriären.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6I lördags slog Cumberland Raceway i Maine, USA, upp portarna för årets säsong och då passade Dave Ingraham på att skriva in sig i historieböckerna när han tog sin 8.000:e seger. Jubileumstriumfen kom med tolvårige valacken Little Macabee (e. Chapter Seven) och segertiden skrevs till 1.16,3/1.609 meter. </p>



<p class="wp-block-paragraph">Dave Ingraham tävlade under många år på Pompano Park och 64-åringen började köra lopp 1980. Hans framgångsrikaste år var 1995 och då bokförde han sig för 2,7 miljoner dollar, medan hans främsta år segermässigt var 1999 med 436 triumfer. </p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7Som femåring var Geir Vegard Gundersen-tränade <strong>Charron</strong> (e. Code Bon) det norska hoppet i Elitloppet förra året och var nära finalplatsen som femma på 1.09,2a efter att ha suttit fast till kort före mål. Nu går träningsrapporterna i dur och Gundersen planerar att årsdebutera sin stjärna i påsk.<br>– Jag säger aldrig nej till Elitloppet och vi får se hur de närmaste veckorna blir. Han ser fruktansvärt bra ut i träning och jag tror att han får en ny fin säsong, säger Geir Vegard till Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Bland många stjärnor har också jänkaren <strong>Devilish Hill</strong> (e. Muscle Hill), trea i Oslo Grand Prix ifjol, i stallet, liksom en nioårig Derbyvinnare – eller ”nästanpensionär” som ”GV” säger om <strong>Cicero T.G. </strong>(e. Kadabra). Ikväll på Bjerke gör hästen årsdebut i ett litet snabblopp med sex hästar över den engelska milen och bland motståndarna finns Frode Hamres italienske segermaskin <strong>Extreme Point</strong> (e. Espoir Prestance) och Sverigebekantingen <strong>Sam The Man</strong> (e. Wishing Stone). Förstapriset är ljumma 35.000 kronor.</p>



<p class="wp-block-paragraph"><strong>Startlista Bjerke</strong><br>1.609 meter autostart<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Canopus</strong> (e. Trixton) – Vidar Hop</li>



<li><strong>Always On Time</strong> (e. Revenue) – Tom Erik Solberg</li>



<li><strong>Cicero T.G.</strong> (e. Kadabra) – Magnus Teien Gundersen</li>



<li><strong>Sam The Man</strong> (e. Wishing Stone) – Erlend Rennesvik</li>



<li><strong>Extreme Point</strong> (e. Espoir Prestance) – Frode Hamre</li>



<li><strong>Cabron</strong> (e. Caballion) – Karoline Aarskog</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Duellen i klassikern
Första steget mot Elitloppsplats. Segermaskin tillbaka efter uppehåll. Svenske mästarens första avkomma till start. Tarzan-uppfödning slog finsktränad stjärna. 64-åring till 8.000 segrar.
Detta och mer bland tisdagens nyheter.
