
<p class="has-drop-cap wp-block-paragraph">Åbytravet står som värd för veckans V75-omgång som därtill är sockrad med jackpot. Prognosen talar för att det ska finnas 49 miljoner i sjurättspotten och det kittlar tveklöst i en omgång som inte ser helt enkel ut på förhand.</p>



<p class="wp-block-paragraph">Vi väljer att spela med två spetsspikar i lägre klasser. Störst förtroende har vi för <strong>Billionaire Face</strong> (V75-5) som vi håller som en för bra häst för Klass II, men förväntar oss även att en felfri <strong>Warrior&#8217;s Tale </strong>(V75-4) håller stången i lärlingsloppet.</p>



<p class="wp-block-paragraph">Han körs åter av en kusk som kan hästen sedan tidigare och &#8221;korta häcken&#8221; faller honom också bäst i smaken.</p>



<p class="wp-block-paragraph">STL Champions – en gång i tiden benämnt som V75 Mästaren – avgörs åter som ett enskilt lopp. Tillställningen är inte helt lättlöst, men trampar <strong>Doctor Gio </strong>(V75-6) iväg på rätt sätt och håller upp innerspåret så är det tveklöst så att Adrian Kolgjini sitter på trumf.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/02/10v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Åby.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2024-02-10_6_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2024-02-10_6_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2024-02-10_6_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Diamantstoet, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Cascabella</strong> blir vårt tipsval i vad som ser ut att vara ett nästan omöjligt Diamantstoförsök. Här kan verkligen allt hända, men Cascabella har visat storform under vintern och tippas i mångt och mycket på det. Senast i Kalmar hade hon just innerspår på 20 meters tillägg och hamnade som femtehäst längs sargen. I slutkurvan satt hon alltjämt sist i fältet, men avslutningen till tredjeplatsen längst ut i banan var av bästa märke. Med bättre klaff här har hon alla möjligheter att ta revansch.</li>



<li><strong>Entrance</strong> är en häst som vi uppfattar det som har mer i sig än vad hon hittills har fått ut, men det kan vara så att det är på väg att lossna på allvar nu. Hon vann från ledningen senast i Örebro och höll då ifrån sig tuffa ston som Precious Thing och Feline Burgerheide efter att sträckt på sig när det stod och vägde. Når hon ledningen även här kan hon bli svårfångad.</li>



<li><strong>Kathrine S.H.</strong> kom fram fint till andra utvändigt efter hand senast på Romme och gick en rejäl 700 metersrepa till vinst. Efter att vunnit ett Diamantstoförsök i november år 2022 har hon som bäst varit fyra i fem försök i lopp med sexsiffrigt förstapris, men nu är hon så pass formstark att hon ska kunna strida även i mer kvalificerad omgivning.</li>



<li><strong>I Love Faux Depart </strong>fick se sig nerplockad av Solkattens Olivia senast på Sundbyholm från ledningen, men gjorde ingen dålig prestation. Det kan vara så att hon är strået vassare med ett rygglopp vilket hon kommer få från detta utgångsläge.</li>



<li><strong>Brilliant Flair </strong>satt i rygg på I Love Faux Depart senast och fick chansen för sent. Hon sköt till bra när luckan väl kom och tillhör de hetare i det här loppet om hon trampar iväg på rätt sätt från snävt startspår.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>9-3-12-8 <strong>B: </strong>4-11-1-6-5-13 <strong>C: </strong>10-2-7-14</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Vikens Takecool</strong> tar ledningen om kusken så vill, men vi tror att det släpps till <strong>Entrance</strong> per omgående.</p>



<h2 class="wp-block-heading">Avd 2 – Klass I, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Cassius Clay D.E. </strong>kunde inte accelerera på bästa sätt från innerspår bakom bilen senast på Axevalla utan hamnade som tredjehäst längs sargen. Han kom ut i andraspår 700 meter före mål, men luckan uppenbarade sig inte förrän in mot upploppet och då var det för sent för att hinna utmana på allvar. Hästen gick i mål med sparade krafter som kan komma väl till hands här och vi bedömer hans startsnabbhet som bättre när han inleder längre ut bakom startbilsvingen. Kan Stefan Persson forcera hästen till ledningen är mycket vunnet.</li>



<li><strong>Jacques Mearas </strong>blev störd i omgångar i Klass II-finalen på Solvalla och vi tar inte så allvarligt på de felsteg som slutligen kom 300 meter före mål. Gången innan vann han sitt försök i Bollnäs efter att öppnat helt okej från samma startspår som han har nu och kunnat forcera sig till tät efter 700 meter. Vi tror att han får svårt att hålla ut värsta konkurrenten här och låter honom därför stå tillbaka i tipset, men annars har vi ingen oro för att hästen inte ska kunna hävda sig i den högre klass som han nu befinner sig i.</li>



<li><strong>Utah Southwind </strong>blev vettigt framdragen från femte utvändigt på Axevalla och avgjorde med lätthet över upploppet. Han står kvar i samma klass och har visat att han klarar av den dryga distans som nu råder, men det föreligger risk att loppet kan bli stiltje en bit och då kan han helt enkelt bli tempotorsk.</li>



<li><strong>Drill</strong> tappade mark på startgalopp senast på Solvalla, men anslöt upp till tredje utvändigt. Han gick en rejäl långspurt som tvåa bakom Mister Jupiter och det var ett glädjande besked att han fungerade så pass tillfredställande med skor på hovarna.</li>



<li><strong>Jollywood </strong>orkade inte hela vägen från ledningen i Klass II-finalen på Solvalla. Nu när det är ytterligare 500 meter längre distans som råder och open stretch finns att tillgå så tror vi att man vill ge hästen ett rygglopp.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5-4 <strong>B: </strong>12-11-1-3-6-8-9 <strong>C: </strong>2-7-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vårt tipsval bygger i mångt och mycket på teorin om att <strong>Cassius Clay D.E. </strong>är snabbare än <strong>Jacques Mearas</strong> den första biten och kan pressa sig fram till tät.</p>



<h2 class="wp-block-heading">Avd 3 – Diamantstoet, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Mose Eagle </strong>fick långt fram från tredje utvändigt senast på Axevalla när attacken sattes in 600 meter före mål och fick därtill en konkurrent framför sig i &#8221;fel skede&#8221;. Hon tog tag bra över upploppet likväl, gick hela vägen in till mållinjen och visade fortsatt god form. Fjolårets vinnare av Tyskt Stoderby är anmäld med jänkarvagn denna gång och vi håller henne som förstahäst i loppet även om hon knappast vinkas fram lättvindigt.</li>



<li><strong>Daytona Roc </strong>galopperade med grepp om spetskampen efter 100 meter i lördags. Hon såg fin ut före loppet och jagar snabb revansch. Vi uppfattar stoet som effektiv från ledningen och tror hon kan ge favoriten en match om segern om hon får överta ledningen från den sannolika ledarinnan Mission Beach.</li>



<li><strong>Rosemary Tile </strong>kunde forceras till ledningen på första långsidan senast på Axevalla, men det tog på krafterna att lägga den tidiga speeden. Från bakspår får hon stå över spetskampen, men det behöver inte alls vara negativt för detta spurtstarka sto.</li>



<li><strong>LaFerrari Dimanche </strong>fick en perfekt resa i andra utvändigt senast på Jägersro och kunde spurta ner tappra Bold Face. Den här hästen har inte blivit så bra som hon såg ut att ha chans att bli under en lovande start av fyraåringssäsongen, men lyfter nu undan för undan och det tycks som att Rick Ebbinge har något bra på gång.</li>



<li><strong>J.J.Another Vinn </strong>skrällvann på Axevalla, men det handlade inte om någon turseger. Stoet var rejäl, tycks trivas förträffligt under vintern och möter ungefär samma typ av motstånd som var fallet i senaste starten.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>2-3 <strong>B: </strong>11-4-6-9-7-12-5<strong> C: </strong>8-1-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Mission Beach </strong>lär fronta i första skedet, men vi tror inte hon körs i tät över full väg mot dessa hästar. <strong>Daytona Roc </strong>kan vara först fram och ta över.</p>



<h2 class="wp-block-heading">Avd 4 – Lärlingslopp, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Warrior&#8217;s Tale </strong>öppnade raskt vid Klass I-starten i Kalmar, men slog på galopp efter 100 meter. Han är inte helt säker i just accelerationsögonblicket, men körs nu av en kusk som kan hästen sedan tidigare och det tycker vi är ett klart plus. Vinner han starten ska han ha jättechans att hålla hela vägen över korta häcken.</li>



<li><strong>Deejay Bar </strong>var en besvikelse i debuten på svensk mark och levde inte alls upp till våra förhoppningar. Han utklassade en så pass bra häst som Dragon&#8217;s Bar vid en start på italiensk mark i förfjol och stod även för häftiga insatser under hösten. Det senaste loppet kan givetvis ha fört honom framåt, men innan vi får bevis på att han är tillbaka med besked så får han stå tillbaka i tipset.</li>



<li><strong>Dancing Days </strong>avslutade riktigt snabbt till vinst i ett överpacat Klass I-försök på Axevalla. När hon har sin dag och är på rätt humör så är hon riktigt rask i benen och kan göra loppet från såväl ledningen som om hon får gå i ryggar.</li>



<li><strong>Farbror Melker </strong>spurtade bra via vinnarhålet och open stretch senast på Åby. Nu åker jänkarvagnen återigen på och det tycker vi är ett klart plus för sexåringen.</li>



<li><strong>Kadabra Dream </strong>hakade på så gott han kunde bakom Moses Boko senast på Åby. Spår tolv är ett hinder, men den korta häcken tycker vi däremot talar till hans fördel.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3 <strong>B: </strong>11-6-5-12 <strong>C: </strong>8-7-4-10-1-9-2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Travar <strong>Warrior&#8217;s Tale</strong> så dyker han till tät. Utifrån är <strong>Farbror Melker</strong> och <strong>Dancing Days</strong> spekulanter vid galopp eller om att få chansen att komma ner bakom.</p>



<h2 class="wp-block-heading">Avd 5 – Klass II, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Billionaire Face</strong> rusade på i överljudsfart näst senast i finalen av Solvallaserien och blev fullt naturligt stum på kuppen. Senast hushöll han dock med krafterna och samlade ihop sig efter en rask öppning och kunde gå undan till säker seger utan att spela ut hela registret. För oss är detta en häst med alldeles för lite pengar på kontot kontra kapacitet och vi förväntar oss att han håller hela vägen nu när det åter ser ut att vara mycket god chans att han tar hand om ledningen.</li>



<li><strong>Nalanji Boko</strong> lyfte under fjolårets sista starter och avslutade treåringssäsongen med en fjärdeplats i Breeders Course Super Bonuslopp. Då hade han toppar som Fiftyfour, Everything Bi samt Boreas före sig i mål och några sådana springare stöter han inte på här. Däremot har inte hästen startat sedan i november och det föreligger frågetecken för formstatusen.</li>



<li><strong>Gloire d&#8217;Empire </strong>forcerades till ledningen senast på Axevalla och dansade undan med lätthet över spurtrakan. Han är obesegrad i två starter efter tävlingsuppehåll och duger tveklöst bra i klassen, men triumferna har tagits från tät och här är förutsättningarna vitt skilda.</li>



<li><strong>I am Don Max </strong>höll bra från ledningen senast på Jägersro då han fick lägga en speed för att överta taktpinnen på nytt. Hästen har sett allmänt positiv ut i ny regi, men ett framspår hade varit att föredra för hans del över stressiga 1.640 meter.</li>



<li><strong>Take Your Time </strong>vann V75-lopp från vinnarhålet på Axevalla, men felade från start gången efter. Står han på benen här har han chans att få rygg på ledaren ånyo och då är han med i kampen om tätplatserna.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5 <strong>B: </strong>9-12-10-1-11-2-7-6 <strong>C: </strong>8-3-4</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Billionaire Fac</strong>e har toppchans att vinna starten och vi tror att <strong>Take Your Time</strong> håller upp vinnarhålet.</p>



<h2 class="wp-block-heading">Avd 6 – STL Champions, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Doctor Gio</strong> såg ut att överforcerats till galopp efter 250 meter vid debuten i sin nya regi, men tog snabb revansch hemma på Jägersro. Då anförde han från start till mål och vann lekande lätt med tillsynes gott om krafter kvar. Vi påminner om att den här hästen var tvåa i Axel Jensens Minneslopp på Bjerke i november bakom Demon på urstarka 1.10,5a/1.609 meter och har mycket hög grundkapacitet för den låga klass han alltjämt befinner sig i. Vore det inte för det finns frågetecken kring hur han trampar iväg från ett sådant här startspår i volten hade vi inte tvekat alls att spika.</li>



<li><strong>Tuppen</strong> galopperade i spetsjakten senast på Åby, men stod för en strålande upphämtning till fjärdeplatsen. Det lös toppform om det intrycket och Tuppen brukar normalt sett kliva iväg såväl snabbt som stabilt ur volten varpå spår två ska kunna gå att leva med.</li>



<li><strong>Real Scotch</strong> fick en tuff väg fram till dödens senast innan han blev avlöst dryga rundan före mål. Han hakade på klart godkänt som fyra och blir lite bättre hela tiden.</li>



<li><strong>Four Guys Dream </strong>galopperade i stridens hetta i Kalmar när han skulle utmana Lulius Boko om segern. Det var det andra raka bakslaget för denna häst som normalt sett trivs väldigt bra under vintern och som känns som det hetaste objektet av tilläggshästarna även om han missgynnas av att de &#8221;bara&#8221; är fem hästar som jagar 20 meter efter.</li>



<li><strong>Beartime</strong> fick för långt fram senast på Axevalla, men avslutningen till fjärdeplatsen var det inget fel på. Får han gå med bakom Four Guys Dream under slutrundan kommer han sannolikt leverera ett raskt upplopp på nytt.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-2-3-13 <strong>B: </strong>12-15-7-9-10-6 <strong>C: </strong>8-5-14-11-4</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Doctor Gios</strong> startsnabbhet är svårbedömd i voltstart och vi blir inte överraskade om <strong>Tuppen</strong> kommer förbi direkt.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Hipster Am </strong>stod helt fel placerad senast i Kalmar och hamnade i kön. Därtill blev hästen störd till galopp i slutkurvan och det loppet är bara att dra ett streck över. Gången innan såg han ut att sitta fast med vinstkrafter i Silverdivisionens final efter att slickat sargen hela vägen och de här förutsättningarna är de smaskigaste han haft på mycket länge. Chansen att han vinner starten är god och från ledningen är han hästen att slå.</li>



<li><strong>Doge As </strong>är dock en värdig utmanare även om det blev galopp för hans del i debuten hos Adrian Kolgjini. Nu rapporteras det om positiva träningsjobb inför den här starten och eventuellt även någon mer stängd form av huvudlag och det känns befogat när det handlar om sprint och läge för att gå &#8221;all in&#8221;. Adrian Kolgjini har gjort ett mycket bra arbete med de italienska hästar som han fick i träning från Alessandro Gocciadoro under senhösten och det här är tveklöst ett spännande ämne som han får jobba med.</li>



<li><strong>Combat Fighter </strong>avslutade mycket bra från fjärde utvändigt i Silverfinalen i lördags och är i toppslag. Givetvis hade Anders Svanstedt önskat sig ett framspår här, men hästen har visat att han även går bakifrån. I rådande formstatus är han så pass tidig i det här loppet att han får ta plats i vår A-grupp.</li>



<li><strong>Game Brodde </strong>övertog ledningen i Silverförsöket på Axevalla och kunde gå undan med lätthet till slut även om Bottnas Idol kom riktigt fort sista biten. Från spår sju når han ingen ledning med katapulter på insidan, men med ett rygglopp är han med och strider om tätplatserna.</li>



<li><strong>Crown Wise As </strong>har gjort flera bra insatser i Jean-Michel Bazires regi på fransk mark och hade börjat lyfta markant redan dessförinnan hos Johan Untersteiner. Vi ser ofta hur hästar som härdats på fransk mark även levererar på en ny nivå vid hemkomst till Sverige, men skotvånget känns inte som någon plusfaktor för Crown Wise As i våra ögon.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>1-3-10 <strong>B: </strong>7-9-4-5-2 <strong>C: </strong>11-6-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Hipster Am</strong> är mycket startsnabb och ska ha god chans att hålla ut <strong>Innovation Love </strong>som lär vikas ner bakom direkt. Vi förväntar oss att <strong>Doge As </strong>sällskapar på ledarens utsida per omgående för han tål att gå på i högt tempo.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 10 FEBRUARI								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,3,4,5,6,8,9,11,12,13 (10,2)<br><strong>Avd 2: </strong>4,5 (12,11)<br><strong>Avd 3: </strong>2,3,4,6,9,11 (7,12)<br><strong>Avd 4:</strong> 3 Warrior&#8217;s Tale (11,6)<br><strong>Avd 5: </strong>5 Billionaire Face (9,12)<br><strong>Avd 6: </strong>1,2,3,12,13,15 (7,9)<br><strong>Avd 7: </strong>1,3,4,7,9,10 (5,2)</p>



<p class="wp-block-paragraph"><em>4.320 rader / 2.160 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
