
<p class="has-drop-cap wp-block-paragraph">1En knatte med över sex miljoner kronor på bankkontot och tio segrar på 27 starter i bagaget. Daniel Redén debuterar jänkaren <strong>Keep Asking</strong> (e. Chapter Seven), 1.09,9ak/6.135.274 kr, i ett fyraåringslopp på Solvalla. Hästen kostade 160.000 dollar på Harrisburgs mixedauktion i höstas och anlände till Redéns stall i slutet av november.<br>– En riktig miniracer och jag trodde att han skulle gå långt över min limit, sade Redén till Sulkysport när hästen var på väg till Sverige.</p>



<p class="wp-block-paragraph">Keep Asking avslutade treåringssäsongen i USA med andraplats i finalen i Massachusetts Breeders Stake ($160.000) för treåriga hingstar och valacker på Plainridge Park den 24 oktober. Detta efter att ha vunnit två försök i serien och dessutom två försök i New York Sire Stakes ($117.700/$59.000).<br>Som tvååring tog Keep Asking hem tre försök och finalen av Massachusetts Breeders Stake ($150.000), samt två försök i New York Sire Stakes ($108.200/$104.400).<br>– Han är en jättefin häst, han är inte stor alltså, 1.46 eller nåt, men det är en jäkla tekniker så det ska bli spännande att se honom i lopp. Han har utvecklats här i vinter och tagit för sig. Fast han är så liten så orkar han med sanden bra. Han har lagt på sig och släppt vinterpälsen, så han ser fin ut. Det ska bli spännande start direkt. Vi börjar med skor runt om och ser var vi har honom. Sedan blir det jänkarvagn, säger Daniel Redén på Stall Zets hemsida.</p>



<p class="wp-block-paragraph">Bland motståndarna finns Breeders Crown-trean <strong>Currency Artist</strong> (e. Royalty For Life) och E3-tvåan <strong>Pretty Be Linda</strong> (e. Varenne).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/danielwajerstenglad-617x333.jpg" alt="" class="wp-image-659824"/><figcaption class="wp-element-caption">Daniel Wäjersten sitter på V86-leken med många fina chanser. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Expresstravet saxas mellan <strong>Solvalla</strong> (första start 18.15) och <strong>Bergsåker</strong> (start 18.27) och nyckeltränaren är utan tvekan Årets tränare i Sverige 2024: Daniel Wäjersten. Han startar totalt 13 hästar ikväll och hade behövt klona sig själv för att köra samtliga. Nio kommer nämligen ut på Bergsåker, medan fyra gör resan söderut till Solvalla.</p>



<p class="wp-block-paragraph">Det är även upplagt för en framgångsrik onsdagskväll. Kvartetten <strong>Randy Zon</strong> (e. Maharajah), <strong>Lionel Mearas</strong> (e. Tactical Landing), <strong>Kingen Mearas</strong> (e. Chapter Seven) och <strong>Diablo</strong> (e. Googoo Gaagaa) är alla klara streckfavoriter i varsin V86-avdelning.<br>– Det ser ut som fyra vettiga chanser på förhand, säger Oskar Florhed i stallet.</p>



<p class="wp-block-paragraph">Läs om stallets alla <a href="https://sulkysport.se/florhed-infor-v86-fyra-vettiga-segerchanser/" target="_blank" rel="noreferrer noopener">starthästar på V86 här</a>.</p>



<p class="wp-block-paragraph"><strong>––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanligt klockan 12.00 idag.</strong></p>



<p class="wp-block-paragraph">Hos vår samarbetspartner Travnet finns andelar till kvällens V86-omgång på Högkvarteret.<br><a href="https://www.atg.se/hogkvarteret/V86_2025-03-19_40_1" target="_blank" rel="noreferrer noopener">Här är alla andelar!</a></p>



<p class="wp-block-paragraph">Utanför streckspelet på Bergsåker dyker flera spännande fyraåriga kallblod upp, där fjolårets tvåa i Svenskt Kallblodskriterium sticker ut. Det handlar om Lars Holm-tränade <strong>Trollbackens Olov</strong> (e. Odin Tabac), som sprang in trekvarts miljon kronor som treåring och vann fem lopp. <br>Ytterligare tre Kriteriefinalister finns med i kvällens försök till Sleipner Cup: Kriteriekvalvinnaren <strong>Gargamel</strong> (e. Galileo), <strong>Bazoo Can</strong> (e. Ängsborken) och <strong>Mitt Hjärtas Hero </strong>(e. Tekno Odin). </p>



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



<p class="has-drop-cap wp-block-paragraph">3Två fina, gamla Solvallamärken från förra millenniet lyfts fram vid kvällens tävlingar. Den ene tvingades byta namn efter att ha vunnit ett klassiskt lopp och den andre utsågs Årets Häst två gånger.</p>



<p class="wp-block-paragraph">I Sören Nordins regi vann <strong>Janbro Active</strong> (född 1975 e. Super Bowl) Svensk Uppfödningslöpning 1977, men hästen bytte namn efter triumfen. En person med efternamnet Janbro ville inte förknippas med travsport och då blev Janbro Active istället <strong>Active Bowler</strong>. Under det nya namnet vann hästen Svenskt Travkriterium, Sprintermästaren och slutade tvåa i Svenskt Travderby.</p>



<p class="wp-block-paragraph"><strong>Dartster F.</strong> (född 1976 e. Dartmouth) var själv en stjärna i Olle Hedins stall, där det blev 40 segrar på 79 starter. Han valdes till Årets Häst i Sverige både 1981 och 1982 och slutade bland annat tvåa bakom Ideal du Gazeau i Elitloppsfinalen 1982 efter att ha vunnit sitt försök.</p>



<p class="wp-block-paragraph">Intresset att tävla i profilernas lopp är dock svalt. Fyra hästar sluter upp i Active Bowlers lopp för treåringar och sex i Dartster F:s lopp, fast kvalitetsmässigt är det inga fel på deltagarna.<br>Marcus Schön Sverigedebuterar treårige <strong>Mimosa to Martini</strong> (e. Gimpanzee), 1.11,0a/1.609 meter, som vann tre av sju starter i Marcus Melanders regi på andra sidan Atlanten förra året.</p>



<p class="wp-block-paragraph">Årsdebuter handlar det också om för Daniel Redéns äldre duo <strong>Double Deceiver</strong> (e. Cantab Hall) och <strong>Missle Hill</strong> (e. Muscle Hill) i snabbloppet. Båda hästarna har över åtta miljoner i prissumma, men får ändå se sig slagna av en av motståndarna. Fredrik B Larssons evighetsmaskin <strong>Milliondollarrhyme</strong> (e. Ready Cash) har passerat nio miljoner.</p>



<p class="wp-block-paragraph">Båda loppen är placerade utanför V86-spelet.</p>



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



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



<p class="has-drop-cap wp-block-paragraph">4 Rena pensionärsträffen blev det i <a href="https://sulkysport.se/elvaarigt-sto-bast-pa-rivieran/" data-type="link" data-id="https://sulkysport.se/elvaarigt-sto-bast-pa-rivieran/" target="_blank" rel="noreferrer noopener">Grand Criterium de Vitesse </a>(€200.000) när elvaåringarna<strong> Emeraude de Bais </strong>(e. Repeat Love) och Etonnant (e. Timoko) slutade etta och tvåa, men duon är inte de enda elvaåringarna som firat framgångar i Grupp I-lopp.</p>



<p class="wp-block-paragraph">När svenskfödde <strong>Commander Crowe</strong> (e. Juliano Star) vann Breeders Crown på Meadowlands och Åby Stora Pris 2014 var han elva år gammal. Elva år var också Victory Tilly (e. Quick Pay) när han slog till i Forus Open 2006.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2018/05/arazibokoml.jpg" alt="" class="wp-image-23986"/><figcaption class="wp-element-caption">Alessandro Gocciadoro och Arazi Boko. . Foto: Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Åldern elva år hade också svenskfödde <strong>Intact Hornline</strong> (e. Lindy’s Crown) nått när han segrade i Gran Premio Duomo och Gran Premio Citta di Montecatini 2003.</p>



<p class="wp-block-paragraph">Svenskfödde <strong>Arazi Boko </strong>(e. Varenne) hade nått samma ålder när han vann Campionato Europeo 2018 och som tolvåring tog han också hem heatloppet i Cesena. Båda gångerna dessutom efter skiljeheat. </p>



<p class="wp-block-paragraph">Arazi Boko nöjde sig inte bara med en Grupp I-seger som tolvåring utan vann också Gran Premio Costa Azzurra, Gran Premio Citta di Montecatini och Gran Premio Duomo. Vad Sulkysport erfar så är Arazi Boko den enda tolvåringen som vunnit Grupp I-lopp.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Nu har den andra hästen bjudits in till Finlandia-Ajo. Först ut var Björn Goops <a href="https://sulkysport.se/san-moteur-till-finlandia-ajo/" data-type="link" data-id="https://sulkysport.se/san-moteur-till-finlandia-ajo/" target="_blank" rel="noreferrer noopener">San Moteur</a> (e. Panne de Moteur) och nu har Christa Packaléns <strong>Jason’s Camden</strong> (e. Muscle Mass), 1.09,5ak/€242.627, fått den andra biljetten.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/03/jasonscamden.jpg-617x411.jpg" alt="" class="wp-image-696788"/><figcaption class="wp-element-caption">Jason&#8217;s Camden. Foto: Maisa Hyttinen</figcaption></figure>



<p class="wp-block-paragraph">– Vi är väldigt glada att gå för att försvara Finlands färger i det största internationella loppet i vårt land, säger Packalén i ett pressmeddelande från Vermo.</p>



<p class="wp-block-paragraph">Jason’s Camden har vunnit 21 av 80 lopp i karriären. I år har valacken startat tre gånger med två segrar och ett andrapris. I senaste starten på Vermo vann han på 1.12,5a/1.620 meter.</p>



<p class="wp-block-paragraph">Förra året slutade Jason’s Camden trea Grupp I-loppet i Kymi Grand Prix bakom <strong>Borups Victory</strong> och Go On Boy, men det blev också fem vinster på 18 starter.</p>



<p class="wp-block-paragraph">Finlandia-Ajo avgörs söndagen den 4 maj med 100.000 euro till vinnaren. Tidigare har Vermo bjudit på en ”svensk” GS75-omgång, men så blir det inte i år utan den kommer att arrangeras i Lindesberg.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Endast en bana tävlar idag på fransk mark och i <strong>Argentan</strong> (första start kl. 13.55) startar två svenskfödda travare i Prix du Chateau de Falaise (€28.000) över 2.800 meter med autostart.</p>



<p class="wp-block-paragraph">Åttaåriga stoet <strong>Maggiore</strong> (e. Googoo Gaagaa) kommer närmast från seger i Prix de Boe (€27.000) i Agen och tränaren Loris Ferro anlitar Gabriele Gelormini i sulkyn denna gång. Från bakspår startar Erik Bondo <strong>Sidney Celeber</strong> (e. Readly Express) och han körs av Eric Raffin.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/argentan-2025-03-19/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/argentan-2025-03-19/" target="_blank" rel="noreferrer noopener">Startlistorna till tävlingarna i Argentan hittar ni här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Första försöksomgången av två till fyraåringsloppet Gran Premio Citta di Torino (€20.900) för hingstar respektive ston avgörs i Rom idag – den andra i Milano på fredag.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/oakstrotto1-617x412.jpg" alt="" class="wp-image-645710"/><figcaption class="wp-element-caption">Marco Stefani och Follia d&#8217;Esi gjorde jobbet utvändigt ledaren i Oaks del Trotto ifjol. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Två av fjolårets italienska toppston möts i det ena försöket. <strong>Follia d’Esi </strong>(e. Ringostarr Treb) tog hem det italienska Stoderbyt Oaks del Trotto (€253.000), medan <strong>Francy Caf</strong> (e. Nad al Sheba) slutade trea i samma löpning.</p>



<p class="wp-block-paragraph">I det andra försöket är <strong>Fantastica Doda</strong> (e. Maharajah) ensam om att ha tjänat sexsiffrigt i euro och hennes största seger under fjolåret kom i stoavdelningen i Gran Premio Citta di Napoli (€66.000).</p>



<p class="wp-block-paragraph">Vinstrikast i hingstarnas försök är <strong>Frankie Lj</strong> (e. Readly Express) med 77.562 intjänade euro och förra året tog han hem Gran Premio Elwood Medium (€37.400)</p>



<h2 class="wp-block-heading">Startlistor:</h2>



<p class="wp-block-paragraph"><strong>Gran Premio Citta di Torino</strong> (€20.900) <strong>– försök 1:</strong><br>Fyraåriga ston.<br><em>2.100 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Fashion Grif </strong>(e. Love You) – Antonio di Nardo</li>



<li><strong>Fitness Grif (</strong>e. Irving Rivarco) – Antonio Simioli</li>



<li><strong>Freccia Laksmy</strong> (e. Maharajah) – Alberto Garruto</li>



<li><strong>Follia d’Esi</strong> (e. Ringostarr Treb) – Marco Stefani</li>



<li><strong>Fantastic Gio</strong> (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Francy Caf </strong>(e. Nad al Sheba) – Roberto Vecchione</li>
</ol>



<p class="wp-block-paragraph"><strong>Försök II:</strong></p>



<ol class="wp-block-list">
<li><strong>Fiorella Jet</strong> (e. Oasis Bi) – Francesco Pettinari</li>



<li><strong>Flamboyant Doda</strong> (e. Maharajah) – Lorenzo Baldi</li>



<li><strong>Frencis Zl </strong>(e. Nad al Sheba) – Marco Stefani</li>



<li><strong>Fort Washakie</strong> (e. Ideale Luis) – Roberto Vecchione</li>



<li><strong>Flavia Bros </strong>(e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Foira Mail </strong>(e. Maharajah) – Antonio di Nardo</li>



<li><strong>Fantastica Doda</strong> (e. Maharajah) – Francesco Facci</li>
</ol>



<p class="wp-block-paragraph"><strong>Gran Premio Citta di Torino </strong>(€20.900) <br>Fyraåriga hingstar.<br><em>2.100 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Fanale Cr</strong> (e. Ready Cash) – Antonio di Nardo</li>



<li><strong>Fantom Jet </strong>(e. Wishing Stone) – Vincenzo Luongo</li>



<li><strong>Floy di Girifalco</strong> (e. Donato Hanover) – Gennaro Riccio</li>



<li><strong>Flyinthedark Gar</strong> (e. Wishing Stone) – Mario Minopoli Jr.</li>



<li><strong>Fellow Wise As</strong> (e. Maharajah) – Alessandro Gocciadoro</li>



<li><strong>Fuoco d’Amore</strong> (e. Mago d’Amore) – Enrico Bellei</li>



<li><strong>Fiero d’Arc</strong> (e. Varenne) – Filippo Gallo</li>



<li><strong>Frankie Lj</strong> (e. Readly Express) – Giampaolo Minnucci</li>



<li><strong>Filippo Wild </strong>(e. Varenne) – Crescenzo Maione</li>



<li><strong>Filodoro Bar</strong> (e. Oropuro Bar) – Roberto Vecchione</li>
</ol>



<p class="wp-block-paragraph">Båda finalerna i Gran Premio Citta di Torino (€200.200) avgörs den 6 april i Turin.</p>
