
<p class="has-drop-cap">1En stark treåringssäsong med seger i Breeders Crown-finalen följdes upp med en ännu bättre säsong ifjol med triumfer i Stochampionatet och ny Breeders Crown-final. Att Daniel Redén-tränade <strong>La Yuca</strong> (e. Face Time Bourbon) blir att räkna med även som femåring visade hon i årsdebuten i Påskägget i Gävle på skärtorsdagen, där hon avgjorde till enkel vinst.</p>



<p>Ikväll på <strong>Solvalla</strong> (första start 18.15) är La Yuca tillbaka på banan. Uppgiften är Avelsföreningens Jubileumslöpning för ston, där den sjufaldiga miljonärskan dragit sjundespår bakom bilen.</p>



<p>– La Yuca löste uppgiften senast på fint sätt och jag var mycket nöjd med vad jag fick se. Det var ett fint svar när Örjan ryckte extraväxlarna den sista biten. Hon har tränat bra efteråt och var fin i tisdagsjobbet. Troligtvis blir det även barfota runt om nu. Det blir även ”biken” på nu när det är bilstart, säger Daniel Redén till sin hemsida <a href="http://reddis.se">reddis.se</a>.</p>



<p>Avelsföreningens Jubileumspris har sett många fina vinnare sedan premiären 2001 och enbart från Redéns stall hittas bland andra <strong>Conrads Rödluva, Double Exposure</strong> och <strong>Sister Sledge</strong>.</p>



<p>Bland La Yucas utmanare ikväll finns 2024 års finska Derbyvinnare <strong>Lightning Stride </strong>(e. Twister Bi), som är tillbaka på svensk mark efter ett äventyr i Frankrike i vinter med dubbla fjärdeplatser på Vincennes som främsta resultat. Ägaren Petri Tarrima, amatörlicens i Halmstad, står numera som tränare för hästen som vann Derbyt i regi Katja Melkko.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/fashiongreen982025gooden-617x347.jpg" alt="" class="wp-image-753573"/><figcaption class="wp-element-caption">Fashion Green vinner för Tim Tetrick. Foto: Chris Gooden</figcaption></figure>



<p>Att Daniel Redén är huvudpersonen på Solvalla råder inget tvivel om. Ett fyraåringslopp med blott fem hästar ser tre hästar från Redéns stall. Mest meriterad är fyrfaldige miljonären <strong>Fashion Green</strong> (e. Greenshoe), som gör Sverigedebut. Valacken har vunnit nio av 13 starter och största segern kom ifjol i finalen av Pennsylvania Sire Stakes ($300.000).</p>



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



<p class="has-drop-cap">2 För 200.000 euro ropade Anders ”Courant” Ström in det fyraåriga franska stoet <strong>Mabellissime</strong> (e. Love You-Elegantissime), 1.12,7m*/€63.630, på Prix d’Amérique-auktionen i januari. I Philippe Allaires regi vann hon tre av sju starter som treåring.</p>



<p>Nu blir det debut på svensk mark i regi Sabine Kagebrant när Mabellissime kommer ut i ett försök i Solvallaserien med Magnus A Djuse i vagnen.</p>



<p>Det är jackpot på kvällens V86-spel med sex miljoner kronor extra i åttarättspotten och Solvalla delar omgången med <strong>Bjerke </strong>(första start 18.27).</p>



<p>På norska huvudstadsbanan jagar lillebrodern till Geir Vegard Gundersens stjärna <strong>Charron</strong>, femårige <strong>Chantecler</strong> (e. Readly Express), andra raka segern. Femåringen står långt efter brodern vad gäller meriter, men visade god form när han vann Thai Tanics Äreslopp över drygt tre kilometer i påskas. Lång distans är uppgiften även i kvällens start på Bjerke.</p>



<p><strong>––> Sulkysports expertpanel bjuder på sina bästa spikar och skrälldrag till omgången, och det publiceras som vanligt vid lunchtid.</strong></p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/simsalabim/V86_2026-04-15_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V86_2026-04-15_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V64_2026-04-14_16_4" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Spelpoolen.</a></p>



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



<p class="has-drop-cap">3 Det tävlas på ytterligare två svenska banor idag. <strong>Åby</strong> brukar vanligtvis dela V86-omgången med Solvalla en gång i månaden, men nu har Mölndalsbanan (första start 17.45) rollen som saxbana.</p>



<p>Johan Untersteiner har ett fyraårigt sto på väg uppåt i klasserna i <strong>Preposterous</strong> (e. Don Fanucci Zet), som inlett karriären med tre segrar på fyra starter. Nu görs resan norrut till Åby för att plocka en fjärde vinst.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/04/palmesusn.o.heat-617x333.jpg" alt="" class="wp-image-837936"/><figcaption class="wp-element-caption">Palmesus N.O. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Onsdagen inleds med lunchtävlingar på <strong>Hagmyren</strong> (start 12.20) och tre kallblod som öppnat säsongen starkt jagar från 20 meters tillägg i det inledande loppet.</p>



<p>Toppstammade femåringen <strong>Palmesus N.O.</strong> – med dubble Derbyvinnaren Nordsjö Odin som pappa och Derbysto-vinnaren Patsi som mamma – visade själv årgångskapacitet ifjol som fyraåring när han slutade fyra i norska Derbyt.</p>



<p>Då tränades han av Öystein Tjomsland, men sedan november återfinns Mellby Gårds travare i Jan-Olov Perssons stall. Där har han inlett lysande med tre segrar och ett andrapris på fyra starter. I senaste starten rekordsänkte han till 1.23,4ak vid vinst.</p>



<p>På tilläggsfållan har Palmesus idag sällskap av Joakim Eskilssons <strong>Höstbo Marcus</strong> (e. B.W.Modde) och Robert Dunders <strong>Grisle Kongen G.L.</strong> (e. Bork Odin) – lillebror till mångmiljonären Grisle Odin G.L. – som vunnit två lopp vardera 2026.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/04/260415.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens 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/2026/03/perengblomjessicahallett-617x530.jpg" alt="" class="wp-image-832818"/><figcaption class="wp-element-caption">Per Engblom. Foto: Jessicca Hallett</figcaption></figure>



<p class="has-drop-cap">4 Sista försöksomgången i John Brennan Series ($30.000) avgörs ikväll amerikansk tid på Yonkers Raceway. Per Engblom har två hästar till start och däribland svenskfödde <a href="https://racing.ustrotting.com/goto.aspx?target=12,103016" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,103016" target="_blank" rel="noreferrer noopener">Zenmeister </a>(e. Perfect Spirit) och han slutade ”bara” tvåa i senaste starten efter ha inlett säsongen med fyra raka triumfer.</p>



<p>I det andra försöket tar Per Engblom ut australiensaren <a href="https://racing.ustrotting.com/goto.aspx?target=12,103017" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,103017" target="_blank" rel="noreferrer noopener">Commodus</a> (e. Father Patrick) och precis som Zenmeister körs han av Jason Bartlett.</p>



<p>Finalen i John Brennan Series ($100.000) avgörs den 22 april på New York-banan och då lockas det med ett förstapris på 50.000 dollar.</p>



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



<p class="has-drop-cap">5 Jörgen Westholm-tränade åker till <strong>Cordemais</strong> (första start kl. 12.00) för att starta <strong>Made of Stars </strong>(e. Super Photo Kosmos) i sadelloppet Prix de la Commune de Savenay (€33.000) över 2.825 meter. Den tioårige valacken står med 25 meters tillägg och rids av Alexis Collette. Förstapriset uppgår till 14.850 euro.</p>



<p>Made of Stars gör sin andra start för säsongen. I årsdebuten i Prix du Pont de Grenelle på Enghien slutade Jörgen Westholms femma.</p>



<p>I Reims (första start kl. 16.52) går Björn Goop-tränade <strong>Keep Out </strong>(e. Dijon) ut i Prix de la Criniere (€21.000) och Jérémy Koubiche tar hand om tömmarna i loppet över 2.500 meter med 9.450 euro till vinnaren.</p>



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



<p class="has-drop-cap">6 <strong>Heaven Am </strong>(e. Bold Eagle-Aromatic), 1.19,8m/500 kr, har fått en son efter Fourth Dimension på Brodda Stuteri.</p>



<p>– Hon ombetäcks med Horsy Dream, säger Peter Dagsberg.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/04/skarmavbild20260414kl.13.30.11.jpg" alt="" class="wp-image-837924"/><figcaption class="wp-element-caption">Heaven Am  med sin son efter Fourth DImension. Foto: privat</figcaption></figure>



<p>Modern Heaven Am är undan passgångaren <strong>Aromatic</strong> (e. Artsplace), 1.12,7. Hon startade aldrig utan tog sitt rekord i ett kvallopp. I avelsboxen har hon varit desto vassare och lämnat passgångarna <strong>Jet Airway </strong>($780.995), <strong>Rockin Airway </strong>($355.021), <strong>Jet Airliner</strong> ($301.210) och <strong>Angel Scent </strong>($208.661). Totalt har hennes avkommor tjänat mer än 3,3 miljoner dollar och vunnit 268 lopp tillsammans.</p>



<p>Heaven Am har tre avkommor sedan tidigare och den förstfödde <strong>Mace Windu</strong> (e. Greenshoe), 1.14,9al/136.000 kr, klubbades för 1,3 miljoner på Solvalla Yearling Sale och han vunnit ett lopp på tio starter.</p>



<p>Ni vet väl att ni kan maila in fölrapporter för fri publicering? Uppge mor, far och kön på fölet. Skriv också om ni bestämt vilken hingst stoet ska gå till i år och skicka gärna med en bild tagen på bredden.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>



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



<p class="has-drop-cap">7 På söndag riktas blickarna mot Breda-banan i Padova. Det vankas Grupp III-lopp – Gran Premio Elwood Medium (€35.300) – för både treåriga hingstar och ston. I hingstarnas uppgörelse hittar vi <strong>Il Trio Jet </strong>(e. Wishing Stone). Den Alessandro Gocciadoro-tränade hästen kommer med en färsk seger i Gran Premio Etruria (€66.000) i bagaget.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/04/iltriojet.jpg" alt="" class="wp-image-837923"/><figcaption class="wp-element-caption">Il Trio Jet. Foto: Victoria Demuru<br></figcaption></figure>



<p>I loppet för de treåriga stona är det <strong>Irma Ferm </strong>(e. The Bank) som bär favoritskapet. Hon har hittills dominerat I-kullen på spinnsidan och senast vann hon stoavdelningen i Gran Premio Italia (€25.300). </p>



<p>Men segern är långtifrån i hamn. Bakom henne lurar flera namnkunniga motståndare, även om spåren ställer till det för vissa. Alessandro Gocciadoros talangfulla <strong>Ingrid Am </strong>(e. El Ideal) har visat storform, men tvingas starta från bakspår. Samma öde har drabbat <strong>I Love America</strong> (e. Muscle Hill), som slutade tvåa bakom Irma Ferm i Gran Premio Masaf.</p>



<p><strong>Gran Premio Elwood Medium </strong>(€35.300)<br>Treåriga hingstar.<br><em>2.040 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Italo Ssg</strong> (e. Maharajah) – Antonio Simioli</li>



<li><strong>Ibra Wind</strong> (e. Readly Express) – Lorenzo Baldi</li>



<li><strong>Ideal Top </strong>(e. Tesoro Degli Dei) – Vincenzo Luongo</li>



<li><strong>Infinito Vf </strong>(e. Alrajah One) – Andrea Farolfi</li>



<li><strong>Invictus Bi</strong> (e. Axl Rose) – Lorenzo Talpo Jr.</li>



<li><strong>Il Trio Jet</strong> (e. Wishing Stone) – Alessandro Gocciadoro</li>



<li><strong>Indianfire Wf</strong> (e. Alrajah One) – Marco Stefani</li>



<li><strong>Illinois Best</strong> (e. Ideale Luis) – Giuseppe de Filippis</li>



<li><strong>Invictus Kb Font </strong>(e. Ringostarr Treb) – Vincenzo P Dell’Annunziata</li>
</ol>



<p><strong>Gran Premio Elwood Medium</strong> (€35.300)<br>Treåriga ston.<br><em>2.040 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Isabelle Indal</strong> (e. Ze Maria) – Rene Legati</li>



<li><strong>Iena Fi </strong>(e. Orlando Vici) – Vincenzo P Dell’Annunziata</li>



<li><strong>Incontrada Grif</strong> (e. Green Manalishi) – Vincenzo Luongo</li>



<li><strong>Isabelle Effe </strong>(e. Googoo Gaagaa) – Antonio Simioli</li>



<li><strong>Ivanka Gso</strong> (e. Volstead) – Andrea Farolfi</li>



<li><strong>Irenel Mail </strong>(e. Nad al Sheba) – Lorenzo Baldi</li>



<li><strong>Ingrid Am </strong>(e. El Ideal) – Alessandro Gocciadoro</li>



<li><strong>Inpendent Gar</strong> (e. Father Patrick) – Manuel Pistone</li>



<li><strong>I Love America</strong> (e. Muscle Hill) – Antonio di Nardo</li>



<li><strong>Igea Trio</strong> (e. The Bank) – Giuseppe de Filippis</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
La Yuca på hemmaplan
Stjärnston på Solvalla. Auktionsdyring i svensk debut. Åby är saxbana. Engblom jagar finalplatser. Nyfött och italienska unghästlopp.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
