
<p class="has-drop-cap wp-block-paragraph">1 Förra året gick Kungapokalen till Solvalla och Drottning Silvias Pokal till utlandet, till Nederländerna. När uttagningsloppen till årets upplagor avgörs på Åby ikväll (första start 18.00) är det tränare på två banor som dominerar sett till antalet hästar. 26 hästar kommer från Solvalla och 20 från Jägersro medan arrangörsbanan Åby inte har med något bidrag.</p>



<p class="wp-block-paragraph">Daniel Redéns <strong>Francesco Zet</strong> (e. Father Patrick) och Paul Hagoorts<strong> Chebba Mil </strong>(e. Readly Express) var vinnarna ifjol och båda har hästar till start i försöken, med tre respektive en häst i Kungapokalen.</p>



<h2 class="wp-block-heading">Banorna med flest hästar anmälda i kvalen:</h2>



<ul class="wp-block-list">
<li>26 hästar: Solvalla</li>



<li>20 hästar: Jägersro</li>



<li>Åtta hästar: Halmstad</li>



<li>Sex hästar: Färjestad</li>



<li>Fyra hästar: Kalmar</li>



<li>Tre hästar: Axevalla, Mantorp</li>



<li>Två hästar: Bergsåker, Boden, Gävle</li>



<li>En häst: Eskilstuna, Romme, Örebro</li>



<li>Fyra hästar tränas utomlands.</li>
</ul>



<p class="wp-block-paragraph">Bakom dessa siffror ryms en hel de fyraåringar med vassa meriter från unghäståren bakom sig. Som stjärnornas stjärna <strong>Joviality</strong> (e. Chapter Seven) – fjolårets vinstrikaste travhäst i världen och med totalt 17.374.854 kronor på priskontot efter 20 segrar på 28 starter på andra sidan Atlanten.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/en-tuff-brud-i-lyxforpackning/" target="_blank" rel="noreferrer noopener">Möt Joviality och nye tränaren Sabine Kagebrant i Sulkysports reportage från gården nära Morgongåva.</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/04/21v64.pdf">Här är startlistorna till uttagningsloppen till Kungapokalen och Drottning Silvias Pokal.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">2 Fredagens lunchtävlingar hämtas från Rättvik (första start 12.20) där ett långlopp för &#8221;bronshästar&#8221; innehåller de mest namnstarka profilerna.</p>



<p class="wp-block-paragraph">Robert Berghs <strong>Jano di Quattro</strong> (e. Bird Parker) som under fjolåret vann Montéryttar-SM gör nu sin första sulkystart för året och möter bland annat Jörgen Westholms <strong>Fenix Brick</strong> (e. Make it Happen) som deltog i fjolårets Harper Hanovers lopp.</p>



<p class="wp-block-paragraph">I det inledande treåringsloppet ska <strong>Fort Knox</strong> (e. Muscle Hill) 1.11,8am/1.127.500 kr halvsyster <strong>Karma Mearas</strong> (e. Face Time Bourbon) försöka följa upp med ny seger och en treåring som kommer från triumf syns även i ett kallblodslopp då Kajsa Fricks <strong>Starkotter</strong> (e. B.W.Modde) gör karriärens andra start.</p>



<p class="wp-block-paragraph">Dagens utbud kompletteras därtill med breddloppstrav från Kalmar (första start 18.30).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/04/230421.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till dagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Vincennes (första start 16.03) arrangerar tre Grupp-lopp under kvällen och Tomas Malmqvist finns representerat i ett av dem.<br>I Prix Aschera (€70.000) för treåriga ston jagar <strong>Kitty Call </strong>(e. Ready Cash) sin tredje seger i karriärens femte start och precis som tidigare är det Adrien Lamy som agerar kusk bakom stoet.</p>



<p class="wp-block-paragraph">Malmqvist prövar även lyckan i Prix Asterope (€53.000) för femåriga hingstar och valacker där<strong> Iron Jet</strong> (e. Charly du Noyer) ska försöka bärga sin andra raka seger.</p>



<p class="wp-block-paragraph">I Prix Theophile Lallouet (€120.000) jagar Prix de Cornulier-tvåan <strong>Grainvillaise Bleue</strong> (e. Jag de Bellouet) sin andra gruppseger för året och ser ut att få bära på ett tungt favoritskap tillsammans med Camille Levesque.<br>Det penningstinna evakueringsloppet Prix Altheia (€90.000) körs utan svenskintressen, men är på intet vis ointressant för det.<br>Jean-Michel Bazire kör själv<strong> Heraut d&#8217;Armes </strong>(e. Ready Cash) som vann Europeiskt Femåringschampionat på Vincennes i höstas och ser fjolårets vinnare av Lady Snärts lopp – <strong>Heliade du Goutier</strong> (e. Prodigious) – som en av utmanarna.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-04-21/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Conrad Lugauer har fått in ett intressant nyförvärv till sitt stall. Det handlar om den femårige italienaren <strong>Corazon Bar </strong>(e. Oropuro Bar) 1.12,4/€118.837 vars treåringssäsong innehöll segrar i såväl Gran Premio Società Terme di Montecatini som Gran Premio Marche och finaldeltagande i Derby Italiano samt Orsi Mangelli.</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2021/05/img3048.jpg" alt="" class="wp-image-169688"/><figcaption class="wp-element-caption">Conrad Lugauer. Foto: stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Därefter har dock karriären gått i stå och efter en mindre lyckad inledning av säsong på fransk mark har hästen flyttats till Jägersrotränaren.</p>



<p class="wp-block-paragraph">Corazon Bar ingår i en syskonskara där nio hästar startat och fyra av dem tjänat över 100.000 euro.<br>Bland dem är <strong>Zaccaria Bar</strong> (e. Ready Cash) 1.09,8ak/€495.655 bäst meriterad med Grupp I-vinst som treåring samt triumf i Grote Prijs Der Giganten under fjolåret.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 På tal om tränarbyten så noterar vi att de övriga hästarna från SRF Stable som tidigare fanns hos Reijo Liljendahl likt <strong>Admiral As</strong> (e. Ready Cash) bytt tränare.<br>Hos Ola Samuelsson finns numera Anders Kilströms Minne-vinnaren <strong>Perpetuate</strong> (e. Kadabra) 1.11,5ak/684.515 kr, <strong>Dear Wise As</strong> (e. Ready Cash) 1.15,5am/70.000 kr samt Admiral As treårige helbror <strong>Emiral As</strong>.</p>



<p class="wp-block-paragraph">Den sistnämnde kostade 220.000 euro då han ropades in på Asta Selezionata Yearlings Trottatori som ettåring och är alltjämt okvalad.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Det är inte bara Pokalkval som avgörs på Åby ikväll. I det inledande loppet gör fem hästar upp om två finalbiljetter till Breeders Course First Final som avgörs på Solvalla under Elitloppsdagen med en miljon kronor till vinnaren.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/feelnopain2210132-617x333.jpg" alt="" class="wp-image-367268"/><figcaption class="wp-element-caption">Glada miner efter Feel No Pains triumf i Svampen i Örebro. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">I kvällens lopp väntar 100.000 kronor på vinnaren och favoritskapet förväntas Daniel Wäjerstens Svampen-vinnare<strong> Feel No Pain</strong> (e. Walner) få bära.<br>Bland konkurrenterna syns Gordon Dahls <strong>Pure Steel</strong> (e. Bird Parker) som vann ett uttagningslopp till Svensk Uppfödningslöpning i höstas, men som galopperade i finalen samt Reijo Liljendahls italienare<strong> Epsom As</strong> (e. Muscle Mass) som är obesegrad efter två starter.</p>



<p class="wp-block-paragraph"><strong>Startlista Uttagningslopp Breeders Course 3 years old 2023 First Final</strong><br><em>2.140 meter autostart, förstapris: 100.000 kronor</em></p>



<ol class="wp-block-list">
<li>The Queen is Back (e. El Mago Pellini) – Anders Svanstedt (Erik Andersson)</li>



<li>Pure Steel (e. Bird Parker) – Thomas Uhrberg (Gordon Dahl)</li>



<li>Feel No Pain (e. Walner) – Daniel Wäjersten</li>



<li>Epsom As (e. Muscle Mass) – Ulf Ohlsson (Reijo Liljendahl)</li>



<li>Yin Yang (e. Bold Eagle) – Robin Bakker (Paul Hagoort)</li>
</ol>



<p class="wp-block-paragraph">Övriga uttagningslopp på svensk mark avgörs på Jägersro under morgondagen, på Solvalla på onsdag samt Jägersro och Solvalla den 10 maj. Det sjätte uttagningsloppet äger rum i Wolvega torsdag den 27 april.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 I ett renodlat fyraåringslopp för ston i Odense (första start 15.45) gör fjolårets vinnaren av Danskt Travkriterium för ston samt Jydsk Treårings GP för ston årsdebut.<br>Det handlar om Bo Westergårds S.J.&#8217;s Caviar-dotter <strong>Hallöjsa Vang</strong> som även visade framhovarna på svensk mark under fjolåret genom att sluta tvåa bakom Tipsy Bartender i Treåringsstoet under Axevallas trippeltravshelg.</p>



<p class="wp-block-paragraph">Ålborgtränaren kör själv stoet i dagens lopp där han även låter svenskfödda <strong>Hello Stone </strong>(e. Wishing Stone) göra comeback efter sju månaders uppehåll.<br>I juli vann stoet Margaretas tidiga Unghästserie på Solvalla tillsammans med Nicklas Korfitsen som kusk och han kör även i dagens lopp.</p>



<p class="wp-block-paragraph"><strong>Startlista</strong><br><strong>2.140 meter autostart, förstapris: 15.000 danska kronor</strong></p>



<ol class="wp-block-list">
<li>Holachia (e. Michel&#8217;s Turn) – Birger Jörgensen<strong> </strong>(Morten Juul)</li>



<li>Hoof Beats Newport (e. Maharajah) – Bent Svendsen</li>



<li>Hertz (e. Readly Express) – Jeppe Juel</li>



<li>Hashtag Ostedantik (e. Great Challenger) – Rene Kjaer<strong> </strong>(Steen Juul)</li>



<li>Heimahey (e. S.J.&#8217;s Caviar) – Steen Juul</li>



<li>Hello Stone (e. Wishing Stone) – Nicklas Korfitsen (Bo Westergård)</li>



<li>Hallöjsa Vang (e. S.J.&#8217;s Caviar) – Bo Westergård</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Solvalla dominerar kvalkvällen
Om banorna som dominerar kvällens Pokalkval, en välstammad miljonär som anslutit hos en Jägersrotränare samt att vägen till ett miljonlopp inleds denna dag går det bland annat att läsa i dagens morgonsvep.
