
<p class="has-drop-cap">1I morgon startar Elisabeth Almheden-tränade bröderna <strong>A Fair Day</strong> (4.021.500 kr) och <strong>Maroon Day</strong> (727.300 kr) inom Jägersros V75-omgång, där A Fair Day jagar plats i Paralympiatravets final när han främst möter <strong>Önas Prince</strong> (e. Chocolatier) och <strong>Barack Face</strong> (e. Ready Cash).<br>Både A Fair Day och Maroon Day har Maharajah som far och det gäller även modern Jolene Days två kommande avkommor treårige <strong>Brother Day</strong> och tvåårige <strong>Jeffery Day</strong>.</p>



<p>Idag inleds travdagen på svensk mark med ett nollopp för treåringar i Bollnäs (första start 12.20) – och där dyker debutanten Brother Day upp! Daniel Redén tränar sedan november hingsten som tränats upp av först Per Nordström och sedan Kenneth Haugstad innan han gick i träning hos Redén.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/04/danielreden-617x333.jpg" alt="" class="wp-image-705606"/><figcaption class="wp-element-caption">Daniel Redén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Kvalloppet på Solvalla för drygt två veckor sedan löste Brother Day på 1.16,4/2.140 meter med tränare Redén i vagnen. I debuten hoppar Örjan Kihlström upp i kampen om förstapriset på 50.000 kronor i Svensk Travsports Unghästserie.<br>– Han var jättefin i kvalet, han joggade förbi en äldre häst på upploppet då. Det är en väldigt fin och trevlig häst på alla sätt och vis. Det är en spännande debut och han har en passande uppgift. Jag hoppas att han har tagit kvalet bra, då blir det intressant, säger Daniel Redén på Stall Zets hemsida.</p>



<p>Bland motståndarna finns en annan debutant, Daniel Wäjersten-tränade <strong>Merlin Mearas </strong>(e. Walner), som är lillebror till Maria Törnqvists segermaskin <strong>Jackpot Mearas</strong> (e. Muscle Hill) med tio vinster på 15 försök.</p>



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



<p class="has-drop-cap">2Kvällens expresstrav med V64 delas mellan Boden (start 18.30) och Halmstad (start 18.20) och på landets nordligaste bana dyker kända märken upp i snabbloppet. Snittåldern på de tio deltagarna är prick tio år och startlistan innehåller några verkliga veteraner.</p>



<p>Som 14-årige <strong>Eder Bob</strong> (e. Crazed) och 13-årige <strong>From The Mine</strong> (e. From Above). Den sistnämnde gör årsdebut och inledde förra årets säsong med seger i just Boden den 12 april… Ungdomarna i loppet är sjuåringarna <strong>King of Djazz</strong> (e. Zola Boko) och <strong>Global Classified</strong> (e. Bold Eagle).<br>Mest meriterad i fältet är Bert Petterssons femfaldige miljonär <strong>Selmer I.H.</strong> (e. Love You), som redan tagit tre segrar och lika många andrapris i år.</p>



<p>Umåkeramatören Anna Näslund tränar Eder Bob och hon har en annan större segerchans ikväll i femårige <strong>Arn Silvio</strong> (e. Readly Express), som inlett 2025 på bästa sätt med två segrar i Boden. Nu ska han från startfållan försöka hålla undan för elva konkurrenter från 20 meters tillägg.</p>



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



<p class="has-drop-cap">3Bara fyra hästar i startlistan, men två av dem tog del av priskakan i Svensk Uppfödningslöpning i höstas. Per Nordström plockar ut två av sina talanger när <strong>Ghirardelli</strong> (e. Googoo Gaagaa) och <strong>Wise Guy</strong> (e. Face Time Bourbon) möts i treåringsloppet i Halmstad ikväll.<br>Ghirardelli slutade femma i uppfödningsloppet och har inlett treåringssäsongen med seger, medan Wise Guy slutade sexa i tvååringarnas största lopp och nu gör årsdebut.<br>Duon ställs mot Robert Berghs <strong>Barkley</strong> (e. Face Time Bourbon), som efter två raka segrar i år slutade trea i Margaretas Tidiga Unghästserie i tredje starten, och Roger Malmqvists <strong>Luna Lane</strong> (e. Cash Gamble), som också vunnit lopp i år.</p>



<p>I Halmstad dyker också 2022 års Derbytrea <strong>Edibear</strong> (e. Make It Happen) upp i ett nytt sammanhang. Sjuåringen ska nämligen testa monté för första gången i tävling (kvalade i disciplinen i september) och Jonathan Carre hoppar upp i sadeln.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/04/250411.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">4Fjolårets treåringskung <strong>Bullet The Bluesky</strong> (e. Readly Express), som efter att ha vunnit Svenskt Travkriterium avslutade säsongen med seger och världsrekord i Breeders Crown-finalen i november, kommer inte att starta i försöken till Kungapokalen annandag påsk.<br>– Beslutet har vuxit fram under våren. Att Europaderbyt avgörs på Solvalla i år fick det att väga över, så jag tog beslutet tillsammans med ägarna att hoppa över Kungapokalen, säger Daniel Wäjersten <a href="https://www.travronden.se/travsport/travtavling/svenska-lopp/a/bullet-the-bluesky-star-over-kungapokalen" target="_blank" rel="noreferrer noopener">till Travronden</a>.<br>Årsdebuten sker enligt Wäjersten i mitten eller slutet av maj.</p>



<p>Bullet The Bluesky gjorde 13 starter (9-2-0) ifjol och sprang in 6.878.000 kronor.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/12/decisionmakerbgm241226adamstromstalltz-617x412.jpg" alt="" class="wp-image-673152"/><figcaption class="wp-element-caption">Decision Maker och Björn Goop vid segern mot hingstarna i gulddivisionens final annandag jul. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">5Hon fick strykas för en svullen kota kort före start av Bergsåker Winter Trot i februari, efter att ha vunnit både guld- och silverfinal under vintern. På onsdag är Nuncio-dottern <strong>Decision Maker</strong> tillbaka på tävlingsbanan i Avelsföreningens Jubileumslöpning för ston med 100.000 kronor till vinnaren. Magnus A Djuse kör och tillsammans har duon fem segrar på sex starter.<br>Årsdebuten avklarad har Daniel Redén-tränade <strong>Felicia Zet</strong>, som varit tvåa i Sto-SM två år i rad. Hon vann ett försök till Diamantstoet i Halmstad i början av mars.</p>



<p>Bakspår drog två högintressanta årsdebutanter. Nästan femfaldiga miljonärskan <strong>Ester Degli Dei</strong> har tjänat merparten av pengarna på svensk mark med Breeders Course- och Breeders Crown-final som treåring som tyngsta titlar. Hon vässade nyligen formen i ett kvallopp i Holland på 1.15,6a/2.100 meter.<br><strong>Don’t Say Gar</strong> har bytt tränare sedan förra säsongen, från Alessandro Gocciadoro till Roger Walmann, och gör debut för sin nya tränare på onsdag.</p>



<p><strong>Startlista Avelsföreningens Jubileumslöpning</strong><br>Solvalla onsdag, 2.140 meter autostart<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Ete Jet (e. Maharajah) – Ulf Ohlsson (Alessandro Gocciadoro)</li>



<li>Enfin Pastis (e. Super Photo Kosmos) – Jorma Kontio (Pontus Sahlin)</li>



<li>Felicia Zet (e. Ready Cash) – Örjan Kihlström (Daniel Redén)</li>



<li>Lady Silver (e. S.J.’s Caviar) – Rikard N Skoglund (Jörgen Westholm)</li>



<li>Waypoint Sequence (e. Uncle Lasse) – Per Lennartsson (Stefan Melander)</li>



<li>Diva Ek (e. Trixton) – Mats E Djuse (Alessandro Gocciadoro)</li>



<li>Decision Maker (e. Nuncio) – Magnus A Djuse (Stefan Melander)</li>



<li>Crazy Life (e. Nuncio) – Björn Goop (Stefan Melander)</li>



<li>Ester Degli Dei (e. Maharajah) – Robin Bakker (Paul Hagoort)</li>



<li>Don’t Say Gar (e. Varenne) – Claes Sjöström (Roger Walmann)</li>
</ol>



<p><a href="https://sulkysport.se/lopp/solvalla-2025-04-16/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Solvallas onsdagstävlingar.</a></p>



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



<p class="has-drop-cap">6Det är svenskt på två håll i Frankrike idag. Den franska travdagen inleds i Toulouse (första start 11.30) och Johan Untersteiner har en häst till start i svensktätt lopp. Untersteiner tar ut <strong>Mateo di Quattro</strong> (e. Bird Parker) i Grand Prix Baron d’Ardeuil (€30.000) med 13.500 euro till vinnaren öve 2.750 meter med bilstart.</p>



<p>Frederic Clozier kör Mateo di Quattro som fått en flygande start på sitt franska äventyr. Efter andraplatsen i debuten på Vincennes vann han i slutet av februari Prix de Luneville (€53.000) på samma bana och de båda starterna har inbringat 35.350 euro.<br>Ytterligare tre svenskfödda travare finns bland de 16 hästarna i loppet: <strong>Dante Godiva</strong> (e. Up And Quick), <strong>Maggiore</strong> (e. Googoo Gaagaa) – med två raka segrar i bagaget – och <strong>Testa di Cavalo</strong> (e. Un Med d’Heripre).</p>



<p>Markus B Svedbergs satsning med fransk filial fortsätter idag på Vincennes, där <strong>Conrads Palle</strong> (e. Brillantissime) gör andra starten i Paris. I debuten på Enghien slutade han trea i ett montélopp. Nu handlar det om sulkylopp och Prix Ariel (€60.000) och Franck Ouvrie sitter i vagnen. Conrads Palle står stenhårt inne på pengarna och har tjänat minst pengar av de 15 deltagarna.<br>Han möter bland annat svenskfödde <strong>Pantocrator</strong> (e. Quarcio du Chene), som varit tvåa som bäst på tre försök i Frankrike.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-04-11/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/jepsoncarljohanadam-617x333.jpg" alt="" class="wp-image-558886"/><figcaption class="wp-element-caption">Carl Johan Jepson toppar allsvenska körsvensligan med stor marginal. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">7När Carl Johan Jepson vann gårdagens tredje lopp på Färjestad blev han först i Sverige att nå 100 segrar som kusk 2025. Det tog 435 starter för att nå tresiffrigt på svensk mark. Jubileumshästen var <strong>King Of Steel</strong> (e. Love You), som tränas av Kim Pedersen.</p>



<p>Jepson har fått en kanonstart på travåret och toppar allsvenska körsvensligan med god marginal före Mats E Djuse (74 segrar på 473 starter) och Magnus A Djuse (73 segrar på 251 starter).<br>Totalt har Carl Johan Jepson vunnit 102 lopp i år med utländska starter inräknade.</p>



<p>Däremot tvingas Jepson till ofrivillig påskledighet på skärtorsdagen, långfredagen och påskafton, då han drog på sig tre dagars avstängning för snäv körning i ett lunchlopp i Örebro förra torsdagen.</p>

Fokustema
Sju nyheter vid sju
Läs senare
I väntan på A Fair Day
A Fair Days lillebror debuterar hos Redén. Veteranernas kamp i Boden...och finalister i uppfödningslöpningen i Halmstad. Kullens kung står över Kungapokalen. Stjärnston i jubileumslöpning på Solvalla.
Detta och mer i fredagens nyhetssvep.
Detta och mer i fredagens nyhetssvep.
