
<p class="has-drop-cap">1 Färjestads långfredagstävlingar har haft den största publiktillströmningen i Sverige i år. 5.356 personer kom till Karlstad för att bevittna toppsport och banans hemmahopp – läs <strong>San Moteur</strong> – i Elitloppet.</p>



<p>Av de 15 V75-omgångar som körts under 2023 har Färjestad den bästa publiksiffran, följd av Åby den 1 april med 3.798 personer på plats. Det finns också några riktiga bottennapp. Fem V75-dagar har körts med färre än 1.000 personer. Halmstads V75-tävlingar den 28 januari lockade 629 personer och mycket bättre var det inte på Färjestad den 7 januari när publiken räknades till 666.</p>



<p>Totalt har 24.951 personer sett V75-tävlingar på plats under 2023, vilket ger ett publiksnitt på inte alltför imponerande 1.663. </p>



<h2 class="wp-block-heading">Publiktoppen 2023</h2>



<p><strong>Bana – Datum – Publik</strong></p>



<ol class="wp-block-list">
<li>Färjestad – 7 april – 5.356</li>



<li>Åby – 1 april – 3.798</li>



<li>Solvalla – 25 mars – 2.288</li>



<li>Bergsåker – 18 februari – 2.230</li>



<li>Solvalla – 5 februari – 1.713</li>
</ol>



<h2 class="wp-block-heading">Publikbotten 2023</h2>



<p><strong>Bana – Datum – Publik</strong></p>



<ol class="wp-block-list">
<li>Halmstad – 28 januari – 629</li>



<li>Färjestad – 7 januari – 666</li>



<li>Östersund – 21 januari – 704</li>



<li>Romme – 25 februari – 763</li>



<li>Halmstad – 11 mars – 919</li>
</ol>



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



<p class="has-drop-cap">2 Efter påsk kommer V64-jackpot. Cirka 680.000 kronor extra ligger i sexrättspotten på tisdagens huvudbana på svensk mark, <strong>Bergsåker</strong> (första start 18.20), där fjolårets kusk- och tränarchampion plockar ut hela sex hästar varav flera heta segerkandidater.<br>På det stora streckspelet handlar det om fyra fyraåringar i fyra olika lopp, där alla antingen är favoriter eller andrahandsfavoriter på förhand.</p>



<p><strong>Tip of the Toe</strong> (e. Walner) har efter tre segrar på de fyra första starterna nu fyra raka andraplatser och försöker bryta den sviten i ett fyraåringslopp för ston.<br>Valacken <strong>Villiam Avenue</strong> (e. Villiam) har debuterat i år och är obesegrad efter två starter. <strong>Arras Beluga Wine</strong> (e. S.J.’s Caviar) är mest meriterad i Wäjersten-kvintetten och var bland annat tvåa i Sanitys lopp i Östersunds V75-omgång i januari, medan <strong>Heartbeat Thunder</strong> (e. Scarlet Knight) inlett säsongen med en andraplats efter vinteruppehåll.</p>



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



<p class="has-drop-cap">3 Fyra svensktränade hästar kommer till start vid dagens tävlingar på <strong>Vincennes </strong>(första start 16.02). Tre av dem syns i treåringsloppet Prix Proserpina (€40.000) och bland dem utmärker sig Jarmo Niskanens <strong>King Babel </strong>(e. Singalo). Hingsten har inlett karriären med två segrar på lika många försök och tas nu till start på den franska nationalarenan för första gången.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/09/bjorngoop-617x333.jpg" alt="" class="wp-image-207314"/><figcaption class="wp-element-caption">Björn Goop är i Paris idag för att köra på Vincennes.. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Bland dem sju motståndarna finns även<strong> Kamikaze du Campus</strong> (e. Ready Cash) som Björn Goop själv är på plats för att köra samt Tomas Malmqvists <strong>Kash Madrik </strong>(e. Ready Cash).</p>



<p>I inledningsloppet Prix Adria (€40.000) för treåriga hingstar och valacker startar Tomas Malmqvist <strong>Kobalt du Vallon</strong> (e. Quaker Jet). Tävlingsdebuten i Caen den 23 mars resulterade i seger och precis som i det loppet så rids hingsten av Eric Raffin denna tisdag.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-04-11/" 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">***</p>



<p class="has-drop-cap">4Det tävlas på ytterligare två svenska banor denna tisdag. På lunchbanan <strong>Rättvik</strong> (första start 12.20) väntar den andra tävlingsdagen av totalt sex (!) i april. Anledningen till de många dagarna i Rättvik är att tre tävlingar flyttats från grannbanan Romme med anledning av kvarkafall på banan.</p>



<p>En av hästarna som dyker upp i Rättvik är Hanna Forslin-tränade <strong>Smiley Brodda</strong> (e. Readly Express). Det fyraåriga stoet har på sex starter aldrig varit sämre än tvåa och jagar nu livets fjärde triumf.</p>



<p>Kvällen kompletteras med breddtrav i <strong>Mantorp</strong> (första start 17.45).</p>



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



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



<p class="has-drop-cap">5 Italienske Derbyvinnaren <strong>Dimitri Ferm </strong>(e. Nad al Sheba) årsdebuterar på söndag i Gran Premio Citta di Torino (€66.000) över medeldistans och inleder från bakspår.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/dimitrifermbaronciniperrucci-617x412.jpg" alt="" class="wp-image-428390"/><figcaption class="wp-element-caption">Dimitri Ferm och Mauro Baroncini. Foto Perrucci.</figcaption></figure>



<p>Ifjol vann Mauro Baroncini-tränade Dimitri Ferm inte bara det italienska Derbyt (€880.000) utan ytterligare tre Grupp I-segrar; Gran Premio Tito Giovanardi (€154.000), Gran Premio Nazionale (€154.000) och Gran Premio Carlo Marangoni (€154.000).</p>



<p>I samma lopp gör italienske tvååringsstjärnan <strong>Denzel Treb</strong> (e. Nuncio) debut för sin nya tränare Enrico Bellei.</p>



<figure class="wp-block-image size-sulky-stor2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/skarmavbild20230410kl.18.14.47-938x711.png" alt="" class="wp-image-428384"/></figure>



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



<p class="has-drop-cap">6 Ord och inga visor…en hästskötare i USA sökte licens i staten Pennsylvania, men Pennsylvania State Horse Racing Commission var stenhårda och skriver i sitt beslut:</p>



<p><em>”Sökanden nekas på grund av att hon har dömts för brott mot eller försök till brott mot lagar, regler eller bestämmelser om hästkapplöpning i någon jurisdiktion. Sökanden avslås på grund av att hon har brutit mot en regel, en bestämmelse eller ett beslut av kommissionen. Sökande nekas på grund av att hon inte med tydliga och övertygande bevis har kunnat visa att hon är en person med god karaktär, ärlighet och integritet. Den sökande nekas på grund av att hon är en person vars tidigare verksamhet, rykte, vanor och sammanslutningar utgör ett hot mot allmänhetens intresse eller mot en effektiv kontroll och reglering av hästkapplöpning. Sökanden nekas tillstånd på grund av att hon är en person vars tidigare verksamhet, rykte, vanor och kontakter skapar eller förstärker risken för olämpliga, orättvisa eller olagliga metoder och verksamheter i samband med hästkapplöpningar eller i samband med affärsverksamhet och finansiella arrangemang som är förknippade med hästkapplöpningar.”</em></p>



<p>Den 31 augusti 2021 dömdes personen ifråga till 1.000 dollar i böter och 300 dagars avstängning efter ha förfalskat en hästägares underskrift utan ägarens vetskap eller tillåtelse. Trots avtjänat straff så visade Pennsylvania State Horse Racing Commission ingen barmhärtighet. </p>



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



<p class="has-drop-cap">7 Två nyfödda travare kan Sulkysport rapportera. <strong>Jetske Beemd </strong>(e. Timoko-Bibi Beemd), 1.12,6ak/*/257.124 kr, har nedkommit med sin första avkomma på Sturelundsgård hos Grönviks Racing Stable. Holländskan blev mor till en hingst efter Önas Prince. Äger gör FM Trotting Invest.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/jetskebeemd-350x467.jpg" alt="" class="wp-image-428349"/><figcaption class="wp-element-caption">Jetske Beeemds hingst efter Önas Prince. Foto: privat</figcaption></figure>



<p>Mormor <strong>Bibi Beemd</strong> (e. General November) ingår i samma syskonskara som trefaldiga holländska Breeders Crown-vinnaren <strong>Ariane Beemd </strong>(e. Passing Renka), 1.11,3ak/2.033.106 kr, och Fokkers Trofee-ettan <strong>Ybanos</strong> (e. Abano As), 1.10,9ak/804.169 kr.</p>



<p>Mor har också <strong>Global Tenderness </strong>(e. S.J.’s Caviar-Umbrella Broline), 1.13,5al/490.700 kr, blivit till en hingst efter Googoo Gaagaa hos Robert Kerttu i Kvibille och det är stoets andra avkomma. Äger gör Stall Tenderness HB.</p>



<p>– Hon ombetäcks med Perfect Spirit, berättar Robert Kerttu.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/globaltenderness-350x421.jpg" alt="" class="wp-image-428350"/></figure>



<p>Global Tenderness är undan <strong>Umbrella Broline</strong> (e. Nordin Hanover), 1.12,9ak/1.059.400 kr, som också lämnat S.J.’s Caviar-duon <strong>Global Withdrawl</strong>, 1.09,9ak/3.493.774 kr, <strong>Global Unspoked</strong>, 1.12,4am/1.214.000 kr, och <strong>Global Legacy</strong> (e. Tom Ridge), 1.12,8ak*/630.700 kr.</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.<br><a href="mailto:claes@sulkysport.se">Maila till Sulkysport</a></p>

Fokustema
Morgonsvepet
Läs senare
Toppen och botten
Färjestad överlägsen bland V75-banor. Wäjerstens vassa hand på hemmaplan. Derbyvinnare årsdebuterar. Fyra svensktränade hästar på Vincennes. Nya fölrapporter.
Det är några av Sulkysports ”sju nyheter vid sju.”
Det är några av Sulkysports ”sju nyheter vid sju.”
